@vellumai/assistant 0.8.2 → 0.8.3

package/src/__tests__/guardian-action-conversation-turn.test.ts

@@ -1,441 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import {
-  createCallSession,
-  createPendingQuestion,
-} from "../calls/call-store.js";
-import { getDb } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-import {
-  createGuardianActionDelivery,
-  createGuardianActionRequest,
-  finalizeFollowup,
-  getFollowupDeliveriesByConversation,
-  getFollowupDeliveriesByDestination,
-  getGuardianActionRequest,
-  markTimedOutWithReason,
-  progressFollowupState,
-  startFollowupFromExpiredRequest,
-  updateDeliveryStatus,
-} from "../memory/guardian-action-store.js";
-import { conversations } from "../memory/schema.js";
-import { processGuardianFollowUpTurn } from "../runtime/guardian-action-conversation-turn.js";
-import type {
-  GuardianFollowUpConversationContext,
-  GuardianFollowUpConversationGenerator,
-  GuardianFollowUpTurnResult,
-} from "../runtime/http-types.js";
-
-initializeDb();
-
-function ensureConversation(id: string): void {
-  const db = getDb();
-  const now = Date.now();
-  db.insert(conversations)
-    .values({
-      id,
-      title: `Conversation ${id}`,
-      createdAt: now,
-      updatedAt: now,
-    })
-    .run();
-}
-
-function resetTables(): void {
-  const db = getDb();
-  db.run("DELETE FROM guardian_action_deliveries");
-  db.run("DELETE FROM guardian_action_requests");
-  db.run("DELETE FROM call_pending_questions");
-  db.run("DELETE FROM call_events");
-  db.run("DELETE FROM call_sessions");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-}
-
-function createAwaitingChoiceRequest(
-  convId: string,
-  opts?: {
-    chatId?: string;
-    externalUserId?: string;
-    conversationId?: string;
-  },
-) {
-  ensureConversation(convId);
-  const session = createCallSession({
-    conversationId: convId,
-    provider: "twilio",
-    fromNumber: "+15550001111",
-    toNumber: "+15550002222",
-  });
-  const pq = createPendingQuestion(session.id, "What is the gate code?");
-  const request = createGuardianActionRequest({
-    kind: "ask_guardian",
-    sourceChannel: "phone",
-    sourceConversationId: convId,
-    callSessionId: session.id,
-    pendingQuestionId: pq.id,
-    questionText: pq.questionText,
-    expiresAt: Date.now() - 10_000,
-  });
-
-  const deliveryConvId = opts?.conversationId ?? `delivery-conv-${request.id}`;
-  if (opts?.conversationId) {
-    ensureConversation(opts.conversationId);
-  } else {
-    ensureConversation(deliveryConvId);
-  }
-  const delivery = createGuardianActionDelivery({
-    requestId: request.id,
-    destinationChannel: "telegram",
-    destinationChatId: opts?.chatId ?? "chat-123",
-    destinationExternalUserId: opts?.externalUserId ?? "user-456",
-    destinationConversationId: deliveryConvId,
-  });
-  updateDeliveryStatus(delivery.id, "sent");
-
-  // Expire the request
-  markTimedOutWithReason(request.id, "call_timeout");
-
-  // Start follow-up (transitions to awaiting_guardian_choice)
-  startFollowupFromExpiredRequest(request.id, "The gate code is 1234");
-
-  return {
-    request: getGuardianActionRequest(request.id)!,
-    delivery,
-    deliveryConvId,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers for creating mock generators
-// ---------------------------------------------------------------------------
-
-function createMockGenerator(
-  result: GuardianFollowUpTurnResult,
-): GuardianFollowUpConversationGenerator {
-  return async (_context: GuardianFollowUpConversationContext) => result;
-}
-
-function createFailingGenerator(): GuardianFollowUpConversationGenerator {
-  return async () => {
-    throw new Error("LLM provider unavailable");
-  };
-}
-
-describe("guardian-action-conversation-turn", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  // ── processGuardianFollowUpTurn: classification ─────────────────────
-
-  test('classifies "call them back" as call_back', async () => {
-    const generator = createMockGenerator({
-      disposition: "call_back",
-      replyText: "Sure, I'll call them back right away.",
-    });
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Yes, call them back",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("call_back");
-    expect(result.replyText).toBe("Sure, I'll call them back right away.");
-  });
-
-  test('classifies "never mind" as decline', async () => {
-    const generator = createMockGenerator({
-      disposition: "decline",
-      replyText: "No problem. Let me know if you change your mind.",
-    });
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Never mind, forget it",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("decline");
-    expect(result.replyText).toBe(
-      "No problem. Let me know if you change your mind.",
-    );
-  });
-
-  test("classifies ambiguous input as keep_pending with clarification", async () => {
-    const generator = createMockGenerator({
-      disposition: "keep_pending",
-      replyText: "Would you like to call them back or send a text message?",
-    });
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "hmm I dunno",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("keep_pending");
-    expect(result.replyText).toContain("call them back");
-  });
-
-  // ── Failure modes ───────────────────────────────────────────────────
-
-  test("generator failure returns keep_pending with safe fallback", async () => {
-    const generator = createFailingGenerator();
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them back please",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("keep_pending");
-    expect(result.replyText.length).toBeGreaterThan(0);
-  });
-
-  test("no generator returns keep_pending with safe fallback", async () => {
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them back",
-      },
-      undefined,
-    );
-
-    expect(result.disposition).toBe("keep_pending");
-    expect(result.replyText.length).toBeGreaterThan(0);
-  });
-
-  test("generator returning empty replyText falls back to keep_pending", async () => {
-    const generator = createMockGenerator({
-      disposition: "call_back",
-      replyText: "",
-    });
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them back",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("keep_pending");
-  });
-
-  test("generator returning invalid disposition falls back to keep_pending", async () => {
-    const generator: GuardianFollowUpConversationGenerator = async () => {
-      return {
-        disposition:
-          "invalid_value" as GuardianFollowUpTurnResult["disposition"],
-        replyText: "Some reply",
-      };
-    };
-
-    const result = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them back",
-      },
-      generator,
-    );
-
-    expect(result.disposition).toBe("keep_pending");
-  });
-
-  test("reply text is always present in the result", async () => {
-    // With generator
-    const generatorResult = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them",
-      },
-      createMockGenerator({
-        disposition: "call_back",
-        replyText: "Calling now!",
-      }),
-    );
-    expect(typeof generatorResult.replyText).toBe("string");
-    expect(generatorResult.replyText.length).toBeGreaterThan(0);
-
-    // Without generator
-    const fallbackResult = await processGuardianFollowUpTurn({
-      questionText: "What is the gate code?",
-      lateAnswerText: "The gate code is 1234",
-      guardianReply: "Call them",
-    });
-    expect(typeof fallbackResult.replyText).toBe("string");
-    expect(fallbackResult.replyText.length).toBeGreaterThan(0);
-
-    // With failing generator
-    const failResult = await processGuardianFollowUpTurn(
-      {
-        questionText: "What is the gate code?",
-        lateAnswerText: "The gate code is 1234",
-        guardianReply: "Call them",
-      },
-      createFailingGenerator(),
-    );
-    expect(typeof failResult.replyText).toBe("string");
-    expect(failResult.replyText.length).toBeGreaterThan(0);
-  });
-
-  // ── Store queries for awaiting_guardian_choice ───────────────────────
-
-  test("getFollowupDeliveriesByDestination returns deliveries in awaiting_guardian_choice", () => {
-    const { request } = createAwaitingChoiceRequest("conv-turn-1", {
-      chatId: "chat-abc",
-      externalUserId: "user-xyz",
-    });
-
-    const deliveries = getFollowupDeliveriesByDestination(
-      "telegram",
-      "chat-abc",
-    );
-    expect(deliveries).toHaveLength(1);
-    expect(deliveries[0].requestId).toBe(request.id);
-  });
-
-  test("getFollowupDeliveriesByDestination returns empty for non-matching channel", () => {
-    createAwaitingChoiceRequest("conv-turn-2", { chatId: "chat-abc" });
-
-    const deliveries = getFollowupDeliveriesByDestination("phone", "chat-abc");
-    expect(deliveries).toHaveLength(0);
-  });
-
-  test("getFollowupDeliveriesByDestination returns empty for expired with followup_state=none", () => {
-    // Create expired request WITHOUT starting follow-up
-    ensureConversation("conv-turn-3");
-    const session = createCallSession({
-      conversationId: "conv-turn-3",
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, "Question?");
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: "conv-turn-3",
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() - 10_000,
-    });
-    ensureConversation(`delivery-conv-${request.id}`);
-    const delivery = createGuardianActionDelivery({
-      requestId: request.id,
-      destinationChannel: "telegram",
-      destinationChatId: "chat-none",
-      destinationExternalUserId: "user-none",
-      destinationConversationId: `delivery-conv-${request.id}`,
-    });
-    updateDeliveryStatus(delivery.id, "sent");
-    markTimedOutWithReason(request.id, "call_timeout");
-
-    // followup_state is 'none' — should not appear
-    const deliveries = getFollowupDeliveriesByDestination(
-      "telegram",
-      "chat-none",
-    );
-    expect(deliveries).toHaveLength(0);
-  });
-
-  test("getFollowupDeliveriesByConversation returns delivery in awaiting_guardian_choice", () => {
-    const { delivery, deliveryConvId } = createAwaitingChoiceRequest(
-      "conv-turn-4",
-      {
-        conversationId: "mac-conv-1",
-      },
-    );
-
-    const found = getFollowupDeliveriesByConversation(deliveryConvId);
-    expect(found).toHaveLength(1);
-    expect(found[0].id).toBe(delivery.id);
-  });
-
-  test("getFollowupDeliveriesByConversation returns empty for non-matching conversation", () => {
-    createAwaitingChoiceRequest("conv-turn-5", {
-      conversationId: "mac-conv-2",
-    });
-
-    const found = getFollowupDeliveriesByConversation("nonexistent-conv");
-    expect(found).toHaveLength(0);
-  });
-
-  // ── State transitions from conversation engine results ──────────────
-
-  test("call_back disposition transitions to dispatching with call_back action", () => {
-    const { request } = createAwaitingChoiceRequest("conv-turn-6");
-
-    // Simulate what the handler does with a call_back disposition
-    const updated = progressFollowupState(
-      request.id,
-      "dispatching",
-      "call_back",
-    );
-    expect(updated).not.toBeNull();
-    expect(updated!.followupState).toBe("dispatching");
-    expect(updated!.followupAction).toBe("call_back");
-  });
-
-  test("decline disposition finalizes to declined", () => {
-    const { request } = createAwaitingChoiceRequest("conv-turn-8");
-
-    const updated = finalizeFollowup(request.id, "declined");
-    expect(updated).not.toBeNull();
-    expect(updated!.followupState).toBe("declined");
-    expect(updated!.followupCompletedAt).toBeGreaterThan(0);
-  });
-
-  test("keep_pending disposition does not change state", () => {
-    const { request } = createAwaitingChoiceRequest("conv-turn-9");
-
-    // No state change for keep_pending — just verify the state is still awaiting_guardian_choice
-    const reloaded = getGuardianActionRequest(request.id);
-    expect(reloaded!.followupState).toBe("awaiting_guardian_choice");
-  });
-
-  test("state transitions are atomic: second call_back after dispatching fails", () => {
-    const { request } = createAwaitingChoiceRequest("conv-turn-10");
-
-    const first = progressFollowupState(request.id, "dispatching", "call_back");
-    expect(first).not.toBeNull();
-
-    // Second attempt: already in dispatching, cannot re-enter dispatching
-    const second = progressFollowupState(
-      request.id,
-      "dispatching",
-      "call_back",
-    );
-    expect(second).toBeNull();
-
-    // Original action preserved
-    const reloaded = getGuardianActionRequest(request.id);
-    expect(reloaded!.followupAction).toBe("call_back");
-  });
-});

package/src/memory/graph/__tests__/remember-description.test.ts

@@ -1,55 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-let flagEnabled = false;
-
-mock.module("../../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
-    flagEnabled,
-}));
-
-import { getRememberDescription } from "../tools.js";
-
-const stubConfig = {} as unknown as Parameters<
-  typeof getRememberDescription
->[0];
-
-describe("getRememberDescription", () => {
-  beforeEach(() => {
-    flagEnabled = false;
-  });
-
-  test("flag off — returns the default high-pressure description", () => {
-    const desc = getRememberDescription(stubConfig);
-    expect(desc).toContain("**CRITICAL:**");
-    expect(desc).toContain("most frequently used tool");
-    expect(desc).toContain("almost every turn");
-  });
-
-  test("flag on — returns the relaxed judgment-framing description", () => {
-    flagEnabled = true;
-    const desc = getRememberDescription(stubConfig);
-    expect(desc).not.toContain("**CRITICAL:**");
-    expect(desc).not.toContain("almost every turn");
-    expect(desc).toContain("a retrospective pass");
-    expect(desc).toContain("Use judgment");
-  });
-
-  test("the two variants differ", () => {
-    flagEnabled = false;
-    const off = getRememberDescription(stubConfig);
-    flagEnabled = true;
-    const on = getRememberDescription(stubConfig);
-    expect(off).not.toBe(on);
-  });
-
-  test("corrections-are-priority language is preserved in BOTH variants", () => {
-    flagEnabled = false;
-    expect(getRememberDescription(stubConfig)).toMatch(
-      /Corrections are.*highest priority/i,
-    );
-    flagEnabled = true;
-    expect(getRememberDescription(stubConfig)).toMatch(
-      /Corrections are.*highest priority/i,
-    );
-  });
-});

package/src/runtime/guardian-action-conversation-turn.ts

@@ -1,99 +0,0 @@
-/**
- * Guardian follow-up conversation engine.
- *
- * When a guardian replies to a post-timeout follow-up prompt (e.g. "would you
- * like to call them back?"), this engine classifies the
- * guardian's intent into a structured disposition and produces a natural reply.
- *
- * Dispositions:
- *   - call_back:     Guardian wants to call the original caller back
- *   - decline:       Guardian declines to follow up ("never mind", "no thanks")
- *   - keep_pending:  Intent is ambiguous — ask for clarification
- *
- * The engine uses the daemon-injected generator (LLM with tool calling) when
- * available, with a safe fallback that keeps the follow-up pending and returns
- * a retry prompt.
- */
-
-import { getLogger } from "../util/logger.js";
-import { getGuardianActionFallbackMessage } from "./guardian-action-message-composer.js";
-import type {
-  GuardianFollowUpConversationContext,
-  GuardianFollowUpConversationGenerator,
-  GuardianFollowUpDisposition,
-  GuardianFollowUpTurnResult,
-} from "./http-types.js";
-
-const log = getLogger("guardian-action-conversation-turn");
-
-// ---------------------------------------------------------------------------
-// Fallback text
-// ---------------------------------------------------------------------------
-
-const FALLBACK_RETRY_TEXT = getGuardianActionFallbackMessage({
-  scenario: "guardian_followup_clarification",
-});
-
-const VALID_DISPOSITIONS: ReadonlySet<string> = new Set([
-  "call_back",
-  "decline",
-  "keep_pending",
-]);
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Process one turn of the guardian follow-up conversation.
- *
- * Uses the daemon-injected generator when available; on failure or absence,
- * returns a safe keep_pending result with a retry prompt so the follow-up
- * stays open for the guardian to try again.
- */
-export async function processGuardianFollowUpTurn(
-  context: GuardianFollowUpConversationContext,
-  generator?: GuardianFollowUpConversationGenerator,
-): Promise<GuardianFollowUpTurnResult> {
-  if (!generator) {
-    log.warn(
-      "No guardian follow-up conversation generator available, using fallback",
-    );
-    return { disposition: "keep_pending", replyText: FALLBACK_RETRY_TEXT };
-  }
-
-  try {
-    const result = await generator(context);
-
-    // Validate the generator's output
-    if (
-      !result ||
-      typeof result.replyText !== "string" ||
-      result.replyText.trim().length === 0
-    ) {
-      log.warn(
-        "Guardian follow-up generator returned invalid result (missing replyText)",
-      );
-      return { disposition: "keep_pending", replyText: FALLBACK_RETRY_TEXT };
-    }
-
-    if (!VALID_DISPOSITIONS.has(result.disposition)) {
-      log.warn(
-        { disposition: result.disposition },
-        "Guardian follow-up generator returned invalid disposition",
-      );
-      return { disposition: "keep_pending", replyText: FALLBACK_RETRY_TEXT };
-    }
-
-    return {
-      disposition: result.disposition as GuardianFollowUpDisposition,
-      replyText: result.replyText.trim(),
-    };
-  } catch (err) {
-    log.warn(
-      { err },
-      "Guardian follow-up conversation generator failed, using fallback",
-    );
-    return { disposition: "keep_pending", replyText: FALLBACK_RETRY_TEXT };
-  }
-}