@vellumai/assistant 0.4.49 → 0.4.51

package/src/__tests__/date-context.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   buildTemporalContext,
-  extractUserTimeZoneFromDynamicProfile,
+  extractUserTimeZoneFromRecall,
 } from "../daemon/date-context.js";
 
 // Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
@@ -152,82 +152,6 @@ describe("buildTemporalContext", () => {
   });
 });
 
-describe("extractUserTimeZoneFromDynamicProfile", () => {
-  test("extracts canonical timezone from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: Timezone is America/New_York.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe(
-      "America/New_York",
-    );
-  });
-
-  test("extracts timezone token from generic profile text when explicit line is absent", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- location: Travels often between Europe and Asia (currently Europe/Paris).",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
-  });
-
-  test("returns null when no valid timezone is present", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: Pacific time",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBeNull();
-  });
-
-  test("extracts UTC/GMT offset tokens from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+2",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT-2");
-  });
-
-  test("extracts GMT negative offset tokens from generic profile text", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- preferences: schedule notifications in GMT-5 whenever possible.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Etc/GMT+5");
-  });
-
-  test("extracts fractional UTC offset tokens from explicit timezone profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+5:30",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:30");
-  });
-
-  test("extracts fractional GMT offset tokens from generic profile text", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- preferences: default reminders to GMT+5:45.",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("+05:45");
-  });
-
-  test("prefers IANA timezone tokens over UTC/GMT offsets in the same profile line", () => {
-    const profile = [
-      "<dynamic-user-profile>",
-      "- timezone: UTC+1 (Europe/Paris)",
-      "</dynamic-user-profile>",
-    ].join("\n");
-    expect(extractUserTimeZoneFromDynamicProfile(profile)).toBe("Europe/Paris");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Weekday baseline — today is Wednesday
 // ---------------------------------------------------------------------------
@@ -615,3 +539,95 @@ describe("trip-planning: timezone-shifted weekend anchors", () => {
     expect(result).toContain("Next weekend: 2026-02-28 – 2026-03-01");
   });
 });
+
+// ---------------------------------------------------------------------------
+// extractUserTimeZoneFromRecall
+// ---------------------------------------------------------------------------
+
+describe("extractUserTimeZoneFromRecall", () => {
+  test("returns null for empty input", () => {
+    expect(extractUserTimeZoneFromRecall("")).toBeNull();
+    expect(extractUserTimeZoneFromRecall("  ")).toBeNull();
+  });
+
+  test("extracts IANA timezone from user_identity section", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's timezone is America/New_York
+User works as a software engineer
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("America/New_York");
+  });
+
+  test("extracts timezone from 'timezone: ...' line in identity", () => {
+    const text = `<memory_context>
+
+<user_identity>
+- name: Alice
+- timezone: Europe/London
+- role: designer
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("Europe/London");
+  });
+
+  test("extracts UTC offset timezone", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's time zone is UTC+5:30
+</user_identity>
+
+</memory_context>`;
+    const result = extractUserTimeZoneFromRecall(text);
+    expect(result).not.toBeNull();
+    // UTC+5:30 should canonicalize to +05:30
+    expect(result).toBe("+05:30");
+  });
+
+  test("falls back to scanning full text when no identity section", () => {
+    const text = `<memory_context>
+
+<relevant_context>
+<episode source="Mar 5">
+User mentioned their timezone is Asia/Tokyo
+</episode>
+</relevant_context>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("Asia/Tokyo");
+  });
+
+  test("returns null when no timezone info present", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's name is Bob
+User works at Acme Corp
+</user_identity>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBeNull();
+  });
+
+  test("prefers identity section over other sections", () => {
+    const text = `<memory_context>
+
+<user_identity>
+User's timezone is America/Chicago
+</user_identity>
+
+<relevant_context>
+<episode source="Mar 5">
+Discussed timezone America/Los_Angeles for the deployment
+</episode>
+</relevant_context>
+
+</memory_context>`;
+    expect(extractUserTimeZoneFromRecall(text)).toBe("America/Chicago");
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -399,4 +399,68 @@ describe("Verification control messages are deterministic (guard)", () => {
       globalThis.fetch = originalFetch;
     }
   });
+
+  test("handleChannelInbound does not allow blocked members to bootstrap with /start gv_<token>", async () => {
+    const { createHash, randomBytes } = await import("node:crypto");
+    const { handleChannelInbound } =
+      await import("../runtime/routes/inbound-message-handler.js");
+    const { createOutboundSession } =
+      await import("../runtime/channel-verification-service.js");
+    const { upsertContactChannel } =
+      await import("../contacts/contacts-write.js");
+
+    const blockedIdentity = {
+      sourceChannel: "telegram",
+      externalUserId: "user-blocked-bootstrap",
+      externalChatId: "chat-blocked-bootstrap",
+      displayName: "Blocked Bootstrap User",
+      status: "blocked",
+      policy: "deny",
+    } as const;
+    upsertContactChannel(blockedIdentity);
+
+    const bootstrapToken = randomBytes(16).toString("hex");
+    const bootstrapTokenHash = createHash("sha256")
+      .update(bootstrapToken)
+      .digest("hex");
+
+    createOutboundSession({
+      channel: "telegram",
+      identityBindingStatus: "pending_bootstrap",
+      destinationAddress: blockedIdentity.externalUserId,
+      bootstrapTokenHash,
+    });
+
+    let processMessageCalled = false;
+    const processMessage = async () => {
+      processMessageCalled = true;
+      return { messageId: "msg-1" };
+    };
+
+    const req = new Request("http://localhost/channels/inbound", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sourceChannel: "telegram",
+        interface: "telegram",
+        conversationExternalId: blockedIdentity.externalChatId,
+        externalMessageId: `msg-blocked-bootstrap-${Date.now()}`,
+        content: `/start gv_${bootstrapToken}`,
+        actorExternalId: blockedIdentity.externalUserId,
+        actorDisplayName: blockedIdentity.displayName,
+        sourceMetadata: {
+          commandIntent: { type: "start", payload: `gv_${bootstrapToken}` },
+        },
+      }),
+    });
+
+    const response = await handleChannelInbound(req, processMessage);
+    const body = (await response.json()) as Record<string, unknown>;
+
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("member_blocked");
+    expect(body.verificationOutcome).toBeUndefined();
+    expect(processMessageCalled).toBe(false);
+  });
 });

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -1427,3 +1427,96 @@ describe("routing invariant: invite handoff bypass for access requests", () => {
     expect(resolved!.status).toBe("approved");
   });
 });
+
+// ===========================================================================
+// SECTION 11: Expired requests are excluded from routing
+// ===========================================================================
+
+describe("routing invariant: expired requests are excluded from pending discovery", () => {
+  beforeEach(() => resetTables());
+
+  test("expired request with hinted IDs is excluded from disambiguation", async () => {
+    const expired = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP001",
+      toolName: "shell",
+      expiresAt: new Date(Date.now() - 10_000).toISOString(),
+    });
+
+    const active = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "ACT001",
+      toolName: "file_write",
+      expiresAt: new Date(Date.now() + 60_000).toISOString(),
+    });
+    registerPendingToolApprovalInteraction(active.id, "conv-1", "file_write");
+
+    // Both IDs are hinted but only the active one should be considered
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "approve",
+        conversationId: "conv-guardian-thread",
+        pendingRequestIds: [expired.id, active.id],
+        approvalConversationGenerator: undefined,
+      }),
+    );
+
+    // Single active request — should apply directly, no disambiguation
+    expect(result.consumed).toBe(true);
+    expect(result.type).toBe("canonical_decision_applied");
+    expect(result.decisionApplied).toBe(true);
+
+    const resolvedActive = getCanonicalGuardianRequest(active.id);
+    expect(resolvedActive!.status).toBe("approved");
+
+    // Expired request untouched
+    const resolvedExpired = getCanonicalGuardianRequest(expired.id);
+    expect(resolvedExpired!.status).toBe("pending");
+  });
+
+  test("all expired hinted requests means no pending found — not consumed", async () => {
+    const expired1 = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP002",
+      toolName: "shell",
+      expiresAt: new Date(Date.now() - 10_000).toISOString(),
+    });
+
+    const expired2 = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-1",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      requestCode: "EXP003",
+      toolName: "file_write",
+      expiresAt: new Date(Date.now() - 5_000).toISOString(),
+    });
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "approve",
+        conversationId: "conv-guardian-thread",
+        pendingRequestIds: [expired1.id, expired2.id],
+        approvalConversationGenerator: undefined,
+      }),
+    );
+
+    // No active pending requests — falls through
+    expect(result.consumed).toBe(false);
+    expect(result.type).toBe("not_consumed");
+    expect(result.decisionApplied).toBe(false);
+  });
+});

package/src/__tests__/history-repair.test.ts

@@ -428,6 +428,251 @@ describe("repairHistory", () => {
     expect(stats.orphanToolResultsDowngraded).toBe(0);
     expect(stats.consecutiveSameRoleMerged).toBe(0);
   });
+
+  test("keeps server_tool_use + web_search_tool_result paired in assistant message", () => {
+    // Both blocks should stay in the assistant message (self-paired)
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search for cats" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "cats" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "stu_1",
+            content: [{ type: "web_search_result", url: "https://cats.com" }],
+          },
+          { type: "text", text: "Here are some results about cats." },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(repaired).toEqual(messages);
+    expect(stats.missingToolResultsInserted).toBe(0);
+    expect(stats.orphanToolResultsDowngraded).toBe(0);
+  });
+
+  test("synthesizes web_search_tool_result in assistant message when missing (interrupted stream)", () => {
+    // If server_tool_use has no paired result (e.g. stream was interrupted),
+    // the synthetic result goes in the SAME assistant message, not a user message
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "test" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "next message" }],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(1);
+
+    // Synthetic result is in the assistant message, not the user message
+    const assistantMsg = repaired[1];
+    expect(assistantMsg.content).toHaveLength(2);
+    expect(assistantMsg.content[1]).toMatchObject({
+      type: "web_search_tool_result",
+      tool_use_id: "stu_1",
+      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+    });
+
+    // User message has no web_search_tool_result
+    const userMsg = repaired[2];
+    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+  });
+
+  test("migrates legacy web_search_tool_result from user message to assistant message", () => {
+    // Old history format: server_tool_use in assistant, web_search_tool_result in user.
+    // Repair: synthesize result in assistant, orphan-downgrade the user-side result.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "srvtoolu_abc",
+            name: "web_search",
+            input: { query: "test" },
+          },
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "bash",
+            input: { cmd: "ls" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_abc",
+            content: [{ type: "web_search_result", url: "https://example.com" }],
+          },
+          { type: "tool_result", tool_use_id: "tu_1", content: "files" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Done" }],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    // Synthetic web_search_tool_result added to assistant message
+    expect(stats.missingToolResultsInserted).toBe(1);
+
+    // The assistant message now has the server pair + client tool_use
+    const assistantMsg = repaired[1];
+    const serverToolUse = assistantMsg.content.find((b) => b.type === "server_tool_use");
+    const webSearchResult = assistantMsg.content.find((b) => b.type === "web_search_tool_result");
+    expect(serverToolUse).toBeDefined();
+    expect(webSearchResult).toBeDefined();
+
+    // The user message has tool_result for tu_1, and the old web_search_tool_result is downgraded
+    const userMsg = repaired[2];
+    expect(stats.orphanToolResultsDowngraded).toBe(1);
+    expect(userMsg.content.some((b) => b.type === "tool_result")).toBe(true);
+    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+  });
+
+  test("trailing server_tool_use gets synthetic result in same assistant message", () => {
+    // No trailing user message needed — result goes in the assistant message
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Go" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "test" },
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(1);
+    // Result is in the assistant message
+    expect(repaired).toHaveLength(2);
+    expect(repaired[1].role).toBe("assistant");
+    expect(repaired[1].content).toHaveLength(2);
+    expect(repaired[1].content[1]).toMatchObject({
+      type: "web_search_tool_result",
+      tool_use_id: "stu_1",
+      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+    });
+  });
+
+  test("downgrades type-mismatched tool_result for server_tool_use", () => {
+    // A tool_result in the user message for a server_tool_use ID is orphaned —
+    // server-side results belong in the assistant message
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search" }] },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "test" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "stu_1", content: "wrong type" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Done" }],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    // Synthetic web_search_tool_result added to assistant message
+    expect(stats.missingToolResultsInserted).toBe(1);
+    // The mismatched tool_result in user message is orphaned (no pending client tool_use)
+    expect(stats.orphanToolResultsDowngraded).toBe(1);
+
+    // Assistant message has the server pair
+    const assistantMsg = repaired[1];
+    expect(assistantMsg.content.some((b) => b.type === "web_search_tool_result")).toBe(true);
+
+    // User message has no web_search_tool_result — the tool_result was downgraded to text
+    const userMsg = repaired[2];
+    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(userMsg.content.every((b) => b.type !== "tool_result")).toBe(true);
+  });
+
+  test("downgrades type-mismatched web_search_tool_result for tool_use", () => {
+    // A web_search_tool_result paired with a regular tool_use ID is a type mismatch
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Go" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "tu_1",
+            content: [{ type: "web_search_result", url: "https://example.com" }],
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Done" }],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.orphanToolResultsDowngraded).toBe(1);
+    expect(stats.missingToolResultsInserted).toBe(1);
+
+    const userMsg = repaired[2];
+    const trBlocks = userMsg.content.filter((b) => b.type === "tool_result");
+    expect(trBlocks).toHaveLength(1);
+    expect(trBlocks[0]).toMatchObject({
+      type: "tool_result",
+      tool_use_id: "tu_1",
+      is_error: true,
+    });
+  });
 });
 
 describe("deepRepairHistory", () => {