@vellumai/assistant 0.8.2 → 0.8.3

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;
-  };
-}

package/src/daemon/handlers/__tests__/config-a2a-complete.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Tests for A2A invite completion handler (sender side).
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import {
+  getAssistantContactMetadata,
+  getContact,
+} from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { findById } from "../../../memory/invite-store.js";
+import { completeA2AInvite, createA2AInvite } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_ingress_invites");
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: {
+  a2aEnabled?: boolean;
+  publicBaseUrl?: string;
+  ingressEnabled?: boolean;
+}): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  if (opts.publicBaseUrl !== undefined) {
+    setNestedValue(raw, "ingress.publicBaseUrl", opts.publicBaseUrl);
+  }
+  if (opts.ingressEnabled !== undefined) {
+    setNestedValue(raw, "ingress.enabled", opts.ingressEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+const ACCEPTOR = {
+  assistantId: "acceptor-assistant-123",
+  displayName: "Acceptor Bot",
+  gatewayUrl: "https://acceptor.example.com",
+};
+
+describe("completeA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "https://sender.example.com",
+      ingressEnabled: true,
+    });
+  });
+
+  test("happy path: promotes placeholder contact and returns sender identity", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.sender).toBeDefined();
+    expect(result.sender!.assistantId).toBe("sender-platform-id-789");
+    expect(result.sender!.gatewayUrl).toBe("https://sender.example.com");
+    expect(result.sender!.displayName).toBeDefined();
+    expect(result.error).toBeUndefined();
+
+    // Verify the placeholder contact was promoted
+    const invite = findById(created.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const contact = getContact(invite!.contactId);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Acceptor Bot");
+    expect(contact!.channels).toHaveLength(1);
+    expect(contact!.channels[0]!.type).toBe("a2a");
+    expect(contact!.channels[0]!.status).toBe("active");
+    expect(contact!.channels[0]!.policy).toBe("allow");
+  });
+
+  test("contact channel address is acceptor.assistantId.toLowerCase()", () => {
+    const created = createA2AInvite({});
+    const acceptorWithUppercase = {
+      ...ACCEPTOR,
+      assistantId: "UPPER-Case-ID-123",
+    };
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: acceptorWithUppercase,
+    });
+    expect(result.success).toBe(true);
+
+    const invite = findById(created.inviteId!);
+    const contact = getContact(invite!.contactId);
+    expect(contact!.channels[0]!.address).toBe("upper-case-id-123");
+    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-ID-123");
+  });
+
+  test("assistantContactMetadata has correct assistantId and gatewayUrl", () => {
+    const created = createA2AInvite({});
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(result.success).toBe(true);
+
+    const invite = findById(created.inviteId!);
+    const metadata = getAssistantContactMetadata(invite!.contactId);
+    expect(metadata).not.toBeNull();
+    expect(metadata!.species).toBe("vellum");
+    expect(metadata!.metadata).toEqual({
+      assistantId: "acceptor-assistant-123",
+      gatewayUrl: "https://acceptor.example.com",
+    });
+  });
+
+  test("invalid token returns not_found error", () => {
+    const result = completeA2AInvite({
+      token: "invalid-token-that-does-not-exist",
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("not_found");
+  });
+
+  test("expired invite returns expired error", () => {
+    // Create an invite that expires immediately
+    const created = createA2AInvite({ expiresInHours: 0 });
+    expect(created.success).toBe(true);
+
+    // The invite was just created with 0 hours expiry, so expiresAt ~= now
+    // Manually expire it by updating the DB
+    const sqlite = getSqlite();
+    sqlite.run(
+      "UPDATE assistant_ingress_invites SET expires_at = ? WHERE id = ?",
+      [Date.now() - 1000, created.inviteId!],
+    );
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("expired");
+  });
+
+  test("already-redeemed by same acceptor returns idempotent success", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    // First completion
+    const first = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(first.success).toBe(true);
+
+    // Second completion with same acceptor
+    const second = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(second.success).toBe(true);
+  });
+
+  test("already-redeemed by different acceptor returns error", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    // First completion
+    const first = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+    expect(first.success).toBe(true);
+
+    // Second completion with different acceptor
+    const second = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: {
+        assistantId: "different-assistant-456",
+        displayName: "Different Bot",
+        gatewayUrl: "https://different.example.com",
+      },
+    });
+
+    expect(second.success).toBe(false);
+    expect(second.error).toBe("already_redeemed_by_other");
+  });
+
+  test("fails before claiming token when public base URL is not configured", () => {
+    const created = createA2AInvite({});
+    expect(created.success).toBe(true);
+
+    setConfig({ publicBaseUrl: "", ingressEnabled: true });
+
+    const result = completeA2AInvite({
+      token: created.token!,
+      senderAssistantId: "sender-platform-id-789",
+      acceptor: ACCEPTOR,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("public base URL");
+
+    // Verify the invite was NOT consumed
+    const invite = findById(created.inviteId!);
+    expect(invite!.status).toBe("active");
+    expect(invite!.useCount).toBe(0);
+  });
+});

package/src/daemon/handlers/__tests__/config-a2a-invite.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Tests for A2A invite creation handler.
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import { getContact } from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { findById } from "../../../memory/invite-store.js";
+import { createA2AInvite, getA2AConfig } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_ingress_invites");
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: {
+  a2aEnabled?: boolean;
+  publicBaseUrl?: string;
+  ingressEnabled?: boolean;
+}): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  if (opts.publicBaseUrl !== undefined) {
+    setNestedValue(raw, "ingress.publicBaseUrl", opts.publicBaseUrl);
+  }
+  if (opts.ingressEnabled !== undefined) {
+    setNestedValue(raw, "ingress.enabled", opts.ingressEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+describe("createA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "https://example.vellum.ai",
+      ingressEnabled: true,
+    });
+  });
+
+  test("returns success with inviteId, token, expiresAt, senderGatewayUrl", () => {
+    const result = createA2AInvite({});
+    expect(result.success).toBe(true);
+    expect(result.inviteId).toBeDefined();
+    expect(result.token).toBeDefined();
+    expect(result.expiresAt).toBeDefined();
+    expect(result.senderGatewayUrl).toBe("https://example.vellum.ai");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("creates invite in DB with source_channel=a2a, status=active, max_uses=1", () => {
+    const result = createA2AInvite({});
+    expect(result.inviteId).toBeDefined();
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+    expect(invite!.sourceChannel).toBe("a2a");
+    expect(invite!.status).toBe("active");
+    expect(invite!.maxUses).toBe(1);
+  });
+
+  test("auto-enables A2A if not already on", () => {
+    // A2A starts disabled
+    expect(getA2AConfig().enabled).toBe(false);
+
+    const result = createA2AInvite({});
+    expect(result.success).toBe(true);
+
+    // A2A should now be enabled
+    expect(getA2AConfig().enabled).toBe(true);
+  });
+
+  test("creates placeholder contact with no channels, bound to invite via contactId", () => {
+    const result = createA2AInvite({});
+    expect(result.inviteId).toBeDefined();
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const contact = getContact(invite!.contactId);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Pending A2A invite");
+    expect(contact!.channels).toHaveLength(0);
+  });
+
+  test("returns error when public base URL is not configured", () => {
+    setConfig({
+      a2aEnabled: false,
+      publicBaseUrl: "",
+      ingressEnabled: true,
+    });
+
+    const result = createA2AInvite({});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("public base URL");
+  });
+
+  test("custom expiry via expiresInHours", () => {
+    const before = Date.now();
+    const result = createA2AInvite({ expiresInHours: 24 });
+    const after = Date.now();
+    expect(result.success).toBe(true);
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const expectedMinMs = before + 24 * 60 * 60 * 1000;
+    const expectedMaxMs = after + 24 * 60 * 60 * 1000;
+    expect(invite!.expiresAt).toBeGreaterThanOrEqual(expectedMinMs);
+    expect(invite!.expiresAt).toBeLessThanOrEqual(expectedMaxMs);
+  });
+
+  test("default expiry is 72 hours", () => {
+    const before = Date.now();
+    const result = createA2AInvite({});
+    const after = Date.now();
+    expect(result.success).toBe(true);
+
+    const invite = findById(result.inviteId!);
+    expect(invite).not.toBeNull();
+
+    const expectedMinMs = before + 72 * 60 * 60 * 1000;
+    const expectedMaxMs = after + 72 * 60 * 60 * 1000;
+    expect(invite!.expiresAt).toBeGreaterThanOrEqual(expectedMinMs);
+    expect(invite!.expiresAt).toBeLessThanOrEqual(expectedMaxMs);
+  });
+});

package/src/daemon/handlers/__tests__/config-a2a-redeem.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Tests for A2A invite redemption handler (receiver side).
+ *
+ * Uses the real DB (via `initializeDb()`) and the test preload which sets
+ * `VELLUM_WORKSPACE_DIR` to a per-file temp directory.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../../config/loader.js";
+import {
+  getAssistantContactMetadata,
+  getContact,
+} from "../../../contacts/contact-store.js";
+import { getSqlite } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { getA2AConfig, redeemA2AInvite } from "../config-a2a.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM assistant_contact_metadata");
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function setConfig(opts: { a2aEnabled?: boolean }): void {
+  const raw = loadRawConfig();
+  if (opts.a2aEnabled !== undefined) {
+    setNestedValue(raw, "a2a.enabled", opts.a2aEnabled);
+  }
+  saveRawConfig(raw);
+  invalidateConfigCache();
+}
+
+const SENDER = {
+  assistantId: "sender-assistant-123",
+  displayName: "Sender Bot",
+  gatewayUrl: "https://sender.example.com",
+};
+
+describe("redeemA2AInvite", () => {
+  beforeEach(() => {
+    resetTables();
+    setConfig({ a2aEnabled: false });
+  });
+
+  test("happy path: creates local contact with sender identity", () => {
+    const result = redeemA2AInvite({ sender: SENDER });
+
+    expect(result.success).toBe(true);
+    expect(result.contactId).toBeDefined();
+    expect(result.alreadyConnected).toBeUndefined();
+    expect(result.error).toBeUndefined();
+
+    const contact = getContact(result.contactId!);
+    expect(contact).not.toBeNull();
+    expect(contact!.displayName).toBe("Sender Bot");
+    expect(contact!.channels).toHaveLength(1);
+    expect(contact!.channels[0]!.type).toBe("a2a");
+    expect(contact!.channels[0]!.status).toBe("active");
+    expect(contact!.channels[0]!.policy).toBe("allow");
+  });
+
+  test("idempotency: already-connected sender returns alreadyConnected", () => {
+    const first = redeemA2AInvite({ sender: SENDER });
+    expect(first.success).toBe(true);
+
+    const second = redeemA2AInvite({ sender: SENDER });
+    expect(second.success).toBe(true);
+    expect(second.alreadyConnected).toBe(true);
+    expect(second.contactId).toBe(first.contactId);
+  });
+
+  test("auto-enables A2A if disabled", () => {
+    setConfig({ a2aEnabled: false });
+
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+
+    // Verify A2A was auto-enabled by checking config
+    const config = getA2AConfig();
+    expect(config.enabled).toBe(true);
+  });
+
+  test("assistantContactMetadata has correct assistantId and gatewayUrl", () => {
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+
+    const metadata = getAssistantContactMetadata(result.contactId!);
+    expect(metadata).not.toBeNull();
+    expect(metadata!.species).toBe("vellum");
+    expect(metadata!.metadata).toEqual({
+      assistantId: "sender-assistant-123",
+      gatewayUrl: "https://sender.example.com",
+    });
+  });
+
+  test("channel address uses sender.assistantId.toLowerCase()", () => {
+    const senderWithUppercase = {
+      ...SENDER,
+      assistantId: "UPPER-Case-SENDER-ID",
+    };
+
+    const result = redeemA2AInvite({ sender: senderWithUppercase });
+    expect(result.success).toBe(true);
+
+    const contact = getContact(result.contactId!);
+    expect(contact!.channels[0]!.address).toBe("upper-case-sender-id");
+    expect(contact!.channels[0]!.externalUserId).toBe("UPPER-Case-SENDER-ID");
+  });
+
+  test("does not make outbound fetch calls", () => {
+    // This test verifies that redeemA2AInvite is purely local — no fetch mock
+    // is installed. If it tried to fetch, the call would fail and the test
+    // would throw.
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+  });
+});