@vellumai/assistant 0.8.2 → 0.8.4

package/src/daemon/conversation.ts

@@ -53,8 +53,8 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
+  setConversationCleanedAt,
 } from "../memory/conversation-crud.js";
-import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
@@ -105,6 +105,7 @@ import {
   type ChannelCapabilities,
   getSlackCompactionWatermarkForPrefix,
   loadSlackChronologicalContext,
+  stripInjectionsForCompaction,
 } from "./conversation-runtime-assembly.js";
 import type { SkillProjectionCache } from "./conversation-skill-tools.js";
 import {
@@ -143,6 +144,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,
@@ -241,7 +249,6 @@ export class Conversation {
   /** @internal */ loadedHistoryPersonalMemoryAllowed?: boolean;
   /** @internal */ voiceCallControlPrompt?: string;
   /** @internal */ transportHints?: string[];
-  /** @internal */ slackRuntimeContextNotice?: string;
   /** @internal */ assistantId?: string;
   /** @internal */ commandIntent?: {
     type: string;
@@ -250,6 +257,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
@@ -489,9 +503,6 @@ export class Conversation {
                 channelPersona: persona.channelPersona,
                 userSlug: persona.userSlug,
                 onboardingContext: this.getOnboardingContext(),
-                isBackgroundConversation: isBackgroundConversationType(
-                  getConversation(this.conversationId)?.conversationType,
-                ),
               });
             })(),
       };
@@ -583,9 +594,6 @@ export class Conversation {
             channelPersona: persona.channelPersona,
             userSlug: persona.userSlug,
             onboardingContext: this.getOnboardingContext(),
-            isBackgroundConversation: isBackgroundConversationType(
-              getConversation(this.conversationId)?.conversationType,
-            ),
           });
         })();
     const tools = buildToolDefinitions();
@@ -1133,6 +1141,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;
+    setConversationCleanedAt(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(
@@ -1165,10 +1199,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/date-context.ts

@@ -326,6 +326,46 @@ function formatLocalDate(date: Date, timeZone: string): string {
   ).padStart(2, "0")}`;
 }
 
+const localTimestampFormatterCache = new Map<string, Intl.DateTimeFormat>();
+
+function getLocalTimestampFormatter(timeZone: string): Intl.DateTimeFormat {
+  let fmt = localTimestampFormatterCache.get(timeZone);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hourCycle: "h23",
+    });
+    localTimestampFormatterCache.set(timeZone, fmt);
+  }
+  return fmt;
+}
+
+/**
+ * Format an epoch-millis instant as `YYYY-MM-DD HH:MM:SS` in the given
+ * IANA timezone. When `timeZone` is omitted or `"UTC"`, falls back to a
+ * pure-UTC `toISOString` slice so callers can opt in incrementally.
+ *
+ * The internal `Intl.DateTimeFormat` is memoized by `timeZone` because
+ * constructing it is ~1ms in V8 — material when rendering long transcripts.
+ */
+export function formatLocalTimestamp(ms: number, timeZone?: string): string {
+  if (!timeZone || timeZone === "UTC") {
+    return new Date(ms).toISOString().replace("T", " ").slice(0, 19);
+  }
+  const parts = getLocalTimestampFormatter(timeZone).formatToParts(
+    new Date(ms),
+  );
+  const v: Record<string, string> = {};
+  for (const p of parts) v[p.type] = p.value;
+  return `${v.year}-${v.month}-${v.day} ${v.hour}:${v.minute}:${v.second}`;
+}
+
 export function resolveTurnTimezoneContext(
   options: TemporalContextOptions = {},
 ): TurnTimezoneContext {

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();

package/src/daemon/guardian-action-generators.ts

@@ -9,12 +9,7 @@ import {
   GUARDIAN_ACTION_COPY_TIMEOUT_MS,
   includesRequiredKeywords,
 } from "../runtime/guardian-action-message-composer.js";
-import type {
-  GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
-  GuardianFollowUpDisposition,
-  GuardianFollowUpTurnResult,
-} from "../runtime/http-types.js";
+import type { GuardianActionCopyGenerator } from "../runtime/http-types.js";
 
 /**
  * Create the daemon-owned guardian action copy generator that resolves
@@ -74,122 +69,3 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
     return cleaned;
   };
 }
-
-// ---------------------------------------------------------------------------
-// Guardian follow-up conversation generator
-// ---------------------------------------------------------------------------
-
-const FOLLOWUP_CONVERSATION_TIMEOUT_MS = 8_000;
-const FOLLOWUP_CONVERSATION_MAX_TOKENS = 300;
-
-const FOLLOWUP_CONVERSATION_SYSTEM_PROMPT =
-  "You are an assistant helping route a guardian's reply to a post-timeout follow-up message. " +
-  "A voice caller asked a question, but the call timed out before the guardian could answer. " +
-  "The guardian has now replied late, and was asked whether they want to call the caller back " +
-  "or skip it. " +
-  "Analyze the guardian's latest reply to determine their intent. " +
-  "When uncertain, default to keep_pending and ask a clarifying question. " +
-  "Always provide a natural, helpful reply along with your decision.";
-
-const FOLLOWUP_CONVERSATION_TOOL_NAME = "followup_decision";
-
-const FOLLOWUP_CONVERSATION_TOOL_SCHEMA = {
-  name: FOLLOWUP_CONVERSATION_TOOL_NAME,
-  description:
-    "Record the guardian's follow-up decision and a natural reply. " +
-    "Call this tool with the determined disposition and a reply to the guardian.",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      disposition: {
-        type: "string",
-        enum: ["call_back", "decline", "keep_pending"],
-        description:
-          "The guardian's intent: call_back to call the original caller, " +
-          "decline to skip the follow-up, " +
-          "keep_pending if the intent is unclear (ask for clarification).",
-      },
-      replyText: {
-        type: "string",
-        description: "A natural language reply to send back to the guardian.",
-      },
-    },
-    required: ["disposition", "replyText"],
-  },
-};
-
-const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
-  "call_back",
-  "decline",
-  "keep_pending",
-]);
-
-/**
- * Create the daemon-owned guardian follow-up conversation generator.
- * Uses tool/function calling to produce structured dispositions alongside
- * natural reply text. Follows the same pattern as
- * createApprovalConversationGenerator().
- */
-export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
-  return async (context) => {
-    const baseProvider = await getConfiguredProvider("guardianQuestionCopy");
-    if (!baseProvider) {
-      throw new Error("No configured provider available for follow-up conversation");
-    }
-    const provider = wrapWithCallSiteRouting(baseProvider, loadConfig());
-
-    const userPrompt = [
-      `Original question from the voice call: "${context.questionText}"`,
-      `Guardian's late answer: "${context.lateAnswerText}"`,
-      `\nGuardian's latest reply: ${context.guardianReply}`,
-    ].join("\n");
-
-    const response = await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
-      [FOLLOWUP_CONVERSATION_TOOL_SCHEMA],
-      FOLLOWUP_CONVERSATION_SYSTEM_PROMPT,
-      {
-        config: {
-          max_tokens: FOLLOWUP_CONVERSATION_MAX_TOKENS,
-          callSite: "guardianQuestionCopy",
-        },
-        signal: AbortSignal.timeout(FOLLOWUP_CONVERSATION_TIMEOUT_MS),
-      },
-    );
-
-    // Extract the tool_use block from the response
-    const toolUseBlock = response.content.find(
-      (block) =>
-        block.type === "tool_use" &&
-        block.name === FOLLOWUP_CONVERSATION_TOOL_NAME,
-    );
-
-    if (!toolUseBlock || toolUseBlock.type !== "tool_use") {
-      throw new Error(
-        "Provider did not return a tool_use block for follow-up decision",
-      );
-    }
-
-    const input = toolUseBlock.input as Record<string, unknown>;
-
-    // Strict validation of the structured output
-    const disposition = input.disposition;
-    if (
-      typeof disposition !== "string" ||
-      !VALID_FOLLOWUP_DISPOSITIONS.has(disposition)
-    ) {
-      throw new Error(`Invalid disposition: ${String(disposition)}`);
-    }
-
-    const replyText = input.replyText;
-    if (typeof replyText !== "string" || replyText.trim().length === 0) {
-      throw new Error("Missing or empty replyText in tool_use response");
-    }
-
-    const result: GuardianFollowUpTurnResult = {
-      disposition: disposition as GuardianFollowUpDisposition,
-      replyText: replyText.trim(),
-    };
-    return result;
-  };
-}