@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/prompts/update-bulletin-job.ts

@@ -1,180 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-
-import { getConfig } from "../config/loader.js";
-import {
-  getMemoryCheckpoint,
-  setMemoryCheckpoint,
-} from "../memory/checkpoints.js";
-import { runBackgroundJob } from "../runtime/background-job-runner.js";
-import { hasReceivedUserMessage } from "../runtime/pre-first-message-gate.js";
-import { getLogger } from "../util/logger.js";
-import {
-  getWorkspaceDirDisplay,
-  getWorkspacePromptPath,
-} from "../util/platform.js";
-
-const log = getLogger("update-bulletin-job");
-
-const HASH_CHECKPOINT_KEY = "updates:last_processed_hash";
-const EMPTY_HASH = "empty";
-/**
- * Hard timeout for the update-bulletin agent turn. The agent reads a small
- * markdown file and (usually) deletes it; 10 minutes is generous headroom for
- * a slow model + any tool calls (e.g. memory writes).
- */
-const UPDATE_BULLETIN_TIMEOUT_MS = 10 * 60 * 1000;
-
-function updateBulletinHint(): string {
-  const workspace = getWorkspaceDirDisplay();
-  return `Check ${workspace}/UPDATES.md — new release notes are present. Apply any assistant-facing behavior changes (new tools, deprecations, memory updates). If the user would benefit from knowing about a user-facing change, surface it only when the next topic makes it relevant — do not interrupt them with a proactive message. When you're done processing, delete the file by running \`cd "${workspace}" && rm UPDATES.md\` (the bare-filename \`rm UPDATES.md\` is auto-allowed; path-qualified deletes are not). A silent no-op is preferable to low-signal chatter.`;
-}
-
-type ReadResult =
-  | { kind: "missing" }
-  | { kind: "error"; err: unknown }
-  | { kind: "ok"; content: string };
-
-function computeHash(content: string): string {
-  return createHash("sha256").update(content).digest("hex");
-}
-
-function readTrimmedContent(path: string): ReadResult {
-  if (!existsSync(path)) return { kind: "missing" };
-  try {
-    return { kind: "ok", content: readFileSync(path, "utf-8").trim() };
-  } catch (err) {
-    return { kind: "error", err };
-  }
-}
-
-/**
- * Fire-and-forget background processor for the release-notes bulletin.
- *
- * If `<workspace>/UPDATES.md` has new (unprocessed) content, this drives a
- * background conversation through `runBackgroundJob` with a hint pointing at
- * the file. De-duplication uses a sha256 content hash stored in the
- * `updates:last_processed_hash` memory checkpoint — an `"empty"` sentinel
- * represents a missing/blank file so the job skips the common no-op case.
- *
- * The function never throws: any error inside `runBackgroundJob` is captured
- * in its structured result (which already emits an `activity.failed`
- * notification) and surrounding errors are logged at `warn` and swallowed,
- * so callers can safely invoke it in a non-awaited context.
- *
- * Checkpoint write rules (intentionally conservative — prefer retry over
- * poisoning the checkpoint when state is ambiguous):
- *   - File missing → checkpoint = `EMPTY_HASH`.
- *   - File present but unreadable → checkpoint UNCHANGED, warn logged.
- *   - `runBackgroundJob` returned `ok: false` → checkpoint UNCHANGED so the
- *     next startup retries. The runner has already emitted an
- *     `activity.failed` notification.
- *   - Job ran successfully + file deleted/empty → checkpoint = `EMPTY_HASH`.
- *   - Job ran successfully + file unchanged → checkpoint = current hash
- *     (agent intentionally left the file).
- */
-export async function runUpdateBulletinJobIfNeeded(): Promise<void> {
-  if (getConfig().updates.enabled === false) {
-    return;
-  }
-
-  // Warm-pool guard: don't process release notes before a real user has
-  // interacted with the assistant. Provider credentials are typically not
-  // registered until the user hatches the image, so this job would fail
-  // and leave a "Background job failed: update-bulletin" row in the
-  // sidebar the user inherits at hatch time. The checkpoint is left
-  // untouched on purpose — once the user sends their first message, the
-  // job runs on the next daemon start (or after the next UPDATES.md
-  // change) with normal semantics.
-  if (!hasReceivedUserMessage()) {
-    log.info(
-      "update-bulletin-job: skipped — daemon has not received a first user message yet",
-    );
-    return;
-  }
-
-  try {
-    const updatesPath = getWorkspacePromptPath("UPDATES.md");
-    const initial = readTrimmedContent(updatesPath);
-
-    if (initial.kind === "error") {
-      log.warn(
-        { err: initial.err, path: updatesPath },
-        "update-bulletin-job: failed to read UPDATES.md; leaving checkpoint unchanged so next startup retries",
-      );
-      return;
-    }
-
-    if (initial.kind === "missing" || initial.content.length === 0) {
-      const stored = getMemoryCheckpoint(HASH_CHECKPOINT_KEY);
-      if (stored !== EMPTY_HASH) {
-        setMemoryCheckpoint(HASH_CHECKPOINT_KEY, EMPTY_HASH);
-      }
-      return;
-    }
-
-    const currentHash = computeHash(initial.content);
-    const stored = getMemoryCheckpoint(HASH_CHECKPOINT_KEY);
-    if (stored === currentHash) {
-      return;
-    }
-
-    const result = await runBackgroundJob({
-      jobName: "update-bulletin",
-      source: "update-bulletin",
-      origin: "updates_bulletin",
-      prompt: updateBulletinHint(),
-      trustContext: {
-        sourceChannel: "vellum",
-        trustClass: "guardian",
-      },
-      callSite: "mainAgent",
-      timeoutMs: UPDATE_BULLETIN_TIMEOUT_MS,
-    });
-
-    if (!result.ok) {
-      log.warn(
-        {
-          conversationId: result.conversationId,
-          errorKind: result.errorKind,
-          err: result.error?.message,
-        },
-        "update-bulletin-job: runBackgroundJob returned ok=false; leaving checkpoint unchanged so next startup retries (failure notification already emitted by runner)",
-      );
-      return;
-    }
-
-    // Re-read after the job completed. We need to know whether the file was
-    // deleted or modified to decide whether to advance the checkpoint.
-    const after = readTrimmedContent(updatesPath);
-
-    if (after.kind === "error") {
-      log.warn(
-        { err: after.err, path: updatesPath },
-        "update-bulletin-job: failed to re-read UPDATES.md after job; leaving checkpoint unchanged so next startup retries",
-      );
-      return;
-    }
-
-    const fileMissingOrEmpty =
-      after.kind === "missing" || after.content.length === 0;
-
-    if (fileMissingOrEmpty) {
-      // The agent (or another process) emptied/removed the file. This is the
-      // expected happy path — record the empty sentinel.
-      setMemoryCheckpoint(HASH_CHECKPOINT_KEY, EMPTY_HASH);
-      return;
-    }
-
-    // Job succeeded and the file is still present — the agent intentionally
-    // left it (or modified it). Record the current hash so we don't re-process
-    // the same content on next startup.
-    setMemoryCheckpoint(HASH_CHECKPOINT_KEY, computeHash(after.content));
-  } catch (err) {
-    log.warn(
-      { err },
-      "update-bulletin-job: outer flow threw; swallowing so callers can fire-and-forget",
-    );
-    return;
-  }
-}

package/src/runtime/guardian-action-followup-executor.ts

@@ -1,306 +0,0 @@
-/**
- * Guardian action follow-up executor.
- *
- * After the conversation engine classifies the guardian's reply as
- * `call_back` and transitions the follow-up state to `dispatching`,
- * this module executes the actual action:
- *
- *   - **call_back**: Starts an outbound call to the counterparty with
- *     context about the guardian's answer.
- *
- * The executor resolves the counterparty from the original call session,
- * dispatches the appropriate action, and returns a result with generated
- * reply text for the guardian's confirmation message.
- *
- * This module is channel-agnostic: both inbound-message-handler (Telegram
- * channels) and session-process (desktop channel) use it.
- */
-
-import { startCall } from "../calls/call-domain.js";
-import { getCallSession } from "../calls/call-store.js";
-import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import {
-  finalizeFollowup,
-  type FollowupAction,
-  getGuardianActionRequest,
-  type GuardianActionRequest,
-} from "../memory/guardian-action-store.js";
-import { getLogger } from "../util/logger.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "./assistant-scope.js";
-import { composeGuardianActionMessageGenerative } from "./guardian-action-message-composer.js";
-import type { GuardianActionCopyGenerator } from "./http-types.js";
-
-const log = getLogger("guardian-action-followup-executor");
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface CounterpartyInfo {
-  phoneNumber: string;
-  /** Human-readable identifier (phone number or name if available). */
-  displayIdentifier: string;
-}
-
-export type FollowupExecutionResult =
-  | { ok: true; action: FollowupAction; guardianReplyText: string }
-  | {
-      ok: false;
-      action: FollowupAction;
-      guardianReplyText: string;
-      error: string;
-    };
-
-// ---------------------------------------------------------------------------
-// Counterparty resolution
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the counterparty (the external person) from the original call
- * session by call direction.
- *
- * - **Inbound calls** (`initiatedFromConversationId` is null): the external
- *   caller is `fromNumber`, the assistant's Twilio number is `toNumber`.
- * - **Outbound calls** (`initiatedFromConversationId` is set): the assistant
- *   placed the call so `fromNumber` is the assistant's number and `toNumber`
- *   is the external callee.
- */
-export function resolveCounterparty(
-  callSessionId: string,
-): CounterpartyInfo | null {
-  const session = getCallSession(callSessionId);
-  if (!session) {
-    log.warn(
-      { callSessionId },
-      "Cannot resolve counterparty: call session not found",
-    );
-    return null;
-  }
-
-  // Outbound calls (startCall) store the assistant's number in fromNumber
-  // and the callee in toNumber. They always have initiatedFromConversationId.
-  const isOutbound = !!session.initiatedFromConversationId;
-  const phoneNumber = isOutbound ? session.toNumber : session.fromNumber;
-
-  if (!phoneNumber) {
-    log.warn(
-      { callSessionId, isOutbound },
-      "Cannot resolve counterparty: no phone number on call session",
-    );
-    return null;
-  }
-
-  return {
-    phoneNumber,
-    displayIdentifier: phoneNumber,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Action dispatchers
-// ---------------------------------------------------------------------------
-
-/**
- * Start an outbound call to the counterparty with context about the
- * guardian's answer. Uses the existing call start domain flow.
- */
-async function executeCallBack(
-  request: GuardianActionRequest,
-  counterparty: CounterpartyInfo,
-): Promise<{ ok: true } | { ok: false; error: string }> {
-  try {
-    const task = request.lateAnswerText
-      ? `Call back regarding a question that was asked earlier: "${request.questionText}". The guardian has provided an answer: "${request.lateAnswerText}". Relay this answer to the person.`
-      : `Call back regarding a question that was asked earlier: "${request.questionText}". The guardian wants to follow up with them.`;
-
-    const callbackContext = [
-      `This is a follow-up callback. The person called earlier and asked: "${request.questionText}".`,
-      request.lateAnswerText
-        ? `The guardian's answer is: "${request.lateAnswerText}".`
-        : null,
-      "Relay this information naturally and ask if they need anything else.",
-    ]
-      .filter(Boolean)
-      .join(" ");
-
-    // Create a conversation for the callback call
-    const convKey = `followup-callback:${request.id}`;
-    const { conversationId } = getOrCreateConversation(convKey);
-
-    const result = await startCall({
-      phoneNumber: counterparty.phoneNumber,
-      task,
-      context: callbackContext,
-      conversationId,
-      assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
-    });
-
-    if (!result.ok) {
-      log.warn(
-        { requestId: request.id, error: result.error },
-        "Failed to start follow-up callback call",
-      );
-      return { ok: false, error: result.error };
-    }
-
-    log.info(
-      {
-        requestId: request.id,
-        callSessionId: result.session.id,
-        counterpartyPhone: counterparty.phoneNumber,
-      },
-      "Follow-up call_back initiated successfully",
-    );
-
-    return { ok: true };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error(
-      {
-        err,
-        requestId: request.id,
-        counterpartyPhone: counterparty.phoneNumber,
-      },
-      "Failed to start follow-up callback call",
-    );
-    return { ok: false, error: message };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Execute a follow-up action after the conversation engine has classified
- * the guardian's intent as call_back and the follow-up
- * state has been transitioned to `dispatching`.
- *
- * On success: finalizes the follow-up to `completed` and returns
- * generated confirmation text for the guardian.
- *
- * On failure: finalizes the follow-up to `failed` and returns
- * generated error text for the guardian.
- */
-export async function executeFollowupAction(
-  requestId: string,
-  action: FollowupAction,
-  generator?: GuardianActionCopyGenerator,
-): Promise<FollowupExecutionResult> {
-  const request = getGuardianActionRequest(requestId);
-  if (!request) {
-    const errorText = await composeGuardianActionMessageGenerative(
-      {
-        scenario: "followup_action_failed",
-        failureReason: "The follow-up request could not be found.",
-      },
-      {},
-      generator,
-    );
-    return {
-      ok: false,
-      action,
-      guardianReplyText: errorText,
-      error: "Request not found",
-    };
-  }
-
-  if (request.followupState !== "dispatching") {
-    const errorText = await composeGuardianActionMessageGenerative(
-      {
-        scenario: "followup_action_failed",
-        failureReason:
-          "This follow-up is no longer in a valid state for execution.",
-      },
-      {},
-      generator,
-    );
-    return {
-      ok: false,
-      action,
-      guardianReplyText: errorText,
-      error: `Invalid followup state: ${request.followupState}`,
-    };
-  }
-
-  // Resolve the counterparty from the original call session
-  const counterparty = resolveCounterparty(request.callSessionId);
-  if (!counterparty) {
-    finalizeFollowup(requestId, "failed");
-    const errorText = await composeGuardianActionMessageGenerative(
-      {
-        scenario: "followup_action_failed",
-        failureReason: "I couldn't find the caller's contact information.",
-      },
-      {},
-      generator,
-    );
-    return {
-      ok: false,
-      action,
-      guardianReplyText: errorText,
-      error: "Counterparty not found",
-    };
-  }
-
-  // Execute the action
-  let actionResult: { ok: true } | { ok: false; error: string };
-
-  if (action === "call_back") {
-    actionResult = await executeCallBack(request, counterparty);
-  } else {
-    // decline is already handled in M5 — should not reach the executor.
-    finalizeFollowup(requestId, "failed");
-    const errorText = await composeGuardianActionMessageGenerative(
-      {
-        scenario: "followup_action_failed",
-        failureReason: "An unexpected action was requested.",
-      },
-      {},
-      generator,
-    );
-    return {
-      ok: false,
-      action,
-      guardianReplyText: errorText,
-      error: `Unsupported action: ${action}`,
-    };
-  }
-
-  if (actionResult.ok) {
-    finalizeFollowup(requestId, "completed");
-
-    const scenario = "followup_call_started" as const;
-    const confirmText = await composeGuardianActionMessageGenerative(
-      {
-        scenario,
-        counterpartyPhone: counterparty.phoneNumber,
-        questionText: request.questionText,
-        lateAnswerText: request.lateAnswerText ?? undefined,
-      },
-      {},
-      generator,
-    );
-
-    return { ok: true, action, guardianReplyText: confirmText };
-  }
-
-  // Action failed
-  finalizeFollowup(requestId, "failed");
-  const errorText = await composeGuardianActionMessageGenerative(
-    {
-      scenario: "followup_action_failed",
-      failureReason: actionResult.error,
-      counterpartyPhone: counterparty.phoneNumber,
-    },
-    {},
-    generator,
-  );
-
-  return {
-    ok: false,
-    action,
-    guardianReplyText: errorText,
-    error: actionResult.error,
-  };
-}