@vellumai/assistant 0.4.56 → 0.4.57

package/src/__tests__/schema-transforms.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, test } from "bun:test";
 
 import type { ToolDefinition } from "../providers/types.js";
 import {
-  injectReasonField,
-  REASON_SKIP_SET,
+  ACTIVITY_SKIP_SET,
+  injectActivityField,
   schemaDefinesProperty,
 } from "../tools/schema-transforms.js";
 
@@ -14,26 +14,26 @@ function makeDef(
   return { name, description: `Tool ${name}`, input_schema: schema };
 }
 
-describe("REASON_SKIP_SET", () => {
-  test("contains expected tool names", () => {
-    expect(REASON_SKIP_SET.has("skill_execute")).toBe(true);
-    expect(REASON_SKIP_SET.has("bash")).toBe(true);
-    expect(REASON_SKIP_SET.has("host_bash")).toBe(true);
-    expect(REASON_SKIP_SET.has("request_system_permission")).toBe(true);
-    expect(REASON_SKIP_SET.size).toBe(4);
+describe("ACTIVITY_SKIP_SET", () => {
+  test("is empty (all tools now define their own activity property)", () => {
+    expect(ACTIVITY_SKIP_SET.size).toBe(0);
   });
 });
 
-describe("injectReasonField", () => {
-  test("injects reason on a tool without it", () => {
+describe("injectActivityField", () => {
+  test("injects activity on a tool without it", () => {
     const defs = [makeDef("my_tool")];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    expect(props.reason).toEqual({ type: "string" });
+    expect(props.activity).toEqual({
+      type: "string",
+      description:
+        "Brief, natural description of what you're doing, shown as a live status update (e.g. 'Checking your project settings')",
+    });
   });
 
-  test("adds reason to required array", () => {
+  test("adds activity to required array", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
@@ -41,9 +41,9 @@ describe("injectReasonField", () => {
         required: ["foo"],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
-    expect(schema.required).toEqual(["foo", "reason"]);
+    expect(schema.required).toEqual(["foo", "activity"]);
   });
 
   test("creates required array if missing", () => {
@@ -53,38 +53,38 @@ describe("injectReasonField", () => {
         properties: { foo: { type: "string" } },
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     const schema = result[0].input_schema as Record<string, unknown>;
-    expect(schema.required).toEqual(["reason"]);
+    expect(schema.required).toEqual(["activity"]);
   });
 
   test("skips tools in skip set (returns unchanged)", () => {
     const defs = [makeDef("bash"), makeDef("host_bash")];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs, new Set(["bash", "host_bash"]));
     // Should be the exact same object references
     expect(Object.is(result[0], defs[0])).toBe(true);
     expect(Object.is(result[1], defs[1])).toBe(true);
-    // No reason injected
+    // No activity injected
     const schema0 = result[0].input_schema as Record<string, unknown>;
     const props0 = schema0.properties as Record<string, unknown>;
-    expect("reason" in props0).toBe(false);
+    expect("activity" in props0).toBe(false);
   });
 
-  test("skips tools that already have reason in properties", () => {
+  test("skips tools that already have activity in properties", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
-        properties: { reason: { type: "number" } },
+        properties: { activity: { type: "number" } },
         required: [],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     // Should be the exact same object reference (no clone needed)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Original reason type preserved
-    expect(props.reason).toEqual({ type: "number" });
+    // Original activity type preserved
+    expect(props.activity).toEqual({ type: "number" });
   });
 
   test("does NOT mutate original definition objects", () => {
@@ -97,10 +97,10 @@ describe("injectReasonField", () => {
     };
     const defs = [makeDef("my_tool", originalSchema)];
 
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
 
     // Original properties object is untouched
-    expect("reason" in originalProps).toBe(false);
+    expect("activity" in originalProps).toBe(false);
     // Original required array is untouched
     expect(originalRequired).toEqual(["foo"]);
     // Original schema properties ref is the same object
@@ -115,40 +115,40 @@ describe("injectReasonField", () => {
 
   test("passes through non-object schemas unchanged", () => {
     const defs = [makeDef("my_tool", { type: "string" })];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("passes through schemas without properties unchanged", () => {
     const defs = [makeDef("my_tool", { type: "object" })];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
-  test("skips tools with reason defined inside allOf member (composite schema)", () => {
+  test("skips tools with activity defined inside allOf member (composite schema)", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
         properties: { foo: { type: "string" } },
         allOf: [
           {
-            properties: { reason: { type: "string" } },
+            properties: { activity: { type: "string" } },
           },
         ],
         required: [],
       }),
     ];
-    const result = injectReasonField(defs);
+    const result = injectActivityField(defs);
     // Should be the exact same object reference (no injection)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Top-level properties should NOT have reason injected
-    expect("reason" in props).toBe(false);
+    // Top-level properties should NOT have activity injected
+    expect("activity" in props).toBe(false);
   });
 
   test("handles empty definitions array", () => {
-    const result = injectReasonField([]);
+    const result = injectActivityField([]);
     expect(result).toEqual([]);
   });
 });
@@ -157,44 +157,44 @@ describe("schemaDefinesProperty", () => {
   test("returns true for direct properties match", () => {
     const schema = {
       type: "object",
-      properties: { reason: { type: "string" } },
+      properties: { activity: { type: "string" } },
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in allOf member", () => {
     const schema = {
-      allOf: [{ properties: { reason: { type: "string" } } }],
+      allOf: [{ properties: { activity: { type: "string" } } }],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in oneOf member", () => {
     const schema = {
       oneOf: [
         { properties: { foo: { type: "string" } } },
-        { properties: { reason: { type: "string" } } },
+        { properties: { activity: { type: "string" } } },
       ],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for property in anyOf member", () => {
     const schema = {
-      anyOf: [{ properties: { reason: { type: "string" } } }],
+      anyOf: [{ properties: { activity: { type: "string" } } }],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns true for nested allOf within oneOf", () => {
     const schema = {
       oneOf: [
         {
-          allOf: [{ properties: { reason: { type: "string" } } }],
+          allOf: [{ properties: { activity: { type: "string" } } }],
         },
       ],
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(true);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(true);
   });
 
   test("returns false when property not defined", () => {
@@ -202,25 +202,85 @@ describe("schemaDefinesProperty", () => {
       type: "object",
       properties: { foo: { type: "string" } },
     };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(false);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
   });
 
-  test("returns false for $ref (fail-closed)", () => {
+  test("returns false for $ref with default behavior (fail-closed)", () => {
     const schema = { $ref: "#/definitions/Foo" };
-    expect(schemaDefinesProperty(schema, "reason")).toBe(false);
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
+  });
+
+  test("returns true for $ref with assume-defined behavior (fail-open)", () => {
+    const schema = { $ref: "#/definitions/Foo" };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true for $ref nested in allOf with assume-defined refBehavior", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false for $ref nested in allOf with assume-undefined refBehavior", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-undefined",
+      }),
+    ).toBe(false);
+  });
+
+  test("returns true for $ref nested in oneOf with assume-defined refBehavior", () => {
+    const schema = {
+      oneOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns true for $ref nested in anyOf with assume-defined refBehavior", () => {
+    const schema = {
+      anyOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(
+      schemaDefinesProperty(schema, "activity", {
+        refBehavior: "assume-defined",
+      }),
+    ).toBe(true);
+  });
+
+  test("returns false for $ref nested in allOf with default refBehavior (fail-closed)", () => {
+    const schema = {
+      allOf: [{ $ref: "#/definitions/Foo" }],
+    };
+    expect(schemaDefinesProperty(schema, "activity")).toBe(false);
   });
 
   test("returns false for null schema", () => {
-    expect(schemaDefinesProperty(null, "reason")).toBe(false);
+    expect(schemaDefinesProperty(null, "activity")).toBe(false);
   });
 
   test("returns false for undefined schema", () => {
-    expect(schemaDefinesProperty(undefined, "reason")).toBe(false);
+    expect(schemaDefinesProperty(undefined, "activity")).toBe(false);
   });
 
   test("returns false for non-object schema", () => {
-    expect(schemaDefinesProperty("not-an-object", "reason")).toBe(false);
-    expect(schemaDefinesProperty(42, "reason")).toBe(false);
-    expect(schemaDefinesProperty(true, "reason")).toBe(false);
+    expect(schemaDefinesProperty("not-an-object", "activity")).toBe(false);
+    expect(schemaDefinesProperty(42, "activity")).toBe(false);
+    expect(schemaDefinesProperty(true, "activity")).toBe(false);
   });
 });

package/src/__tests__/secret-onetime-send.test.ts

@@ -14,9 +14,29 @@ const mockConfig = {
   timeouts: { permissionTimeoutSec: 300 },
 };
 
+function setMockNestedValue(
+  obj: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): void {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  setNestedValue: setMockNestedValue,
   invalidateConfigCache: () => {},
 }));
 

package/src/__tests__/secret-routes-managed-proxy.test.ts

@@ -24,9 +24,12 @@ const mockConfig = {
     "image-generation": {
       mode: "your-own" as const,
       provider: "gemini",
-      model: "gemini-2.5-flash-image",
+      model: "gemini-3.1-flash-image-preview",
+    },
+    "web-search": {
+      mode: "your-own" as const,
+      provider: "inference-provider-native",
     },
-    "web-search": { mode: "your-own" as const, provider: "anthropic-native" },
   },
 };
 

package/src/__tests__/secret-scanner-executor.test.ts

@@ -20,8 +20,7 @@ const mockConfig = {
     shellMaxTimeoutSec: 600,
     permissionTimeoutSec: 300,
   },
-  sandbox: { enabled: false },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
     action: "warn" as "redact" | "warn" | "block",

package/src/__tests__/send-endpoint-busy.test.ts

@@ -16,7 +16,10 @@ mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 import { createGuardianBinding } from "../contacts/contacts-write.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
-import { createCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
+import {
+  createCanonicalGuardianRequest,
+  getCanonicalGuardianRequest,
+} from "../memory/canonical-guardian-store.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 
 const testDir = realpathSync(
@@ -49,7 +52,7 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
     services: {
@@ -61,9 +64,9 @@ mock.module("../config/loader.js", () => ({
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
-        model: "gemini-2.5-flash-image",
+        model: "gemini-3.1-flash-image-preview",
       },
-      "web-search": { mode: "your-own", provider: "anthropic-native" },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
   }),
 }));
@@ -896,4 +899,60 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
 
     await stopServer();
   });
+
+  test("auto-deny resolves canonical guardian request so stale records do not cause pending_interaction_not_found", async () => {
+    const conversationKey = "conv-auto-deny-canonical";
+    const { conversationId } = getOrCreateConversation(conversationKey);
+    const requestId = "req-auto-deny-canonical";
+
+    // Step 1: Create a pending approval conversation with a canonical request.
+    const { conversation, denyAllPendingConfirmationsMock } =
+      makePendingApprovalConversation(requestId, false);
+
+    pendingInteractions.register(requestId, {
+      conversation,
+      conversationId,
+      kind: "confirmation",
+    });
+    createCanonicalGuardianRequest({
+      id: requestId,
+      kind: "tool_approval",
+      sourceType: "desktop",
+      sourceChannel: "vellum",
+      conversationId,
+      toolName: "bash",
+      guardianPrincipalId: "test-principal-id",
+      status: "pending",
+      requestCode: "STALE1",
+      expiresAt: Date.now() + 5 * 60 * 1000,
+    });
+
+    await startServer(() => conversation);
+
+    // Step 2: Send a non-approval message to trigger auto-deny of the
+    // pending confirmation. "do something else" is not an approval phrase,
+    // so tryConsumeCanonicalGuardianReply won't consume it, and the
+    // auto-deny path will fire.
+    const res = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        conversationKey,
+        content: "do something else instead",
+        sourceChannel: "vellum",
+        interface: "macos",
+      }),
+    });
+    expect(res.status).toBe(202);
+    expect(denyAllPendingConfirmationsMock).toHaveBeenCalledTimes(1);
+
+    // Step 3: Verify the canonical guardian request was resolved to "denied".
+    // Without the fix, this would remain "pending", causing
+    // pending_interaction_not_found errors on subsequent "yes" messages.
+    const canonicalRequest = getCanonicalGuardianRequest(requestId);
+    expect(canonicalRequest).toBeDefined();
+    expect(canonicalRequest!.status).toBe("denied");
+
+    await stopServer();
+  });
 });

package/src/__tests__/send-notification-tool.test.ts

@@ -39,7 +39,7 @@ describe("send-notification tool", () => {
     expect(emitNotificationSignalMock).toHaveBeenCalledWith({
       sourceEventName: "user.send_notification",
       sourceChannel: "assistant_tool",
-      sourceSessionId: "conv-override",
+      sourceContextId: "conv-override",
       attentionHints: {
         requiresAction: true,
         urgency: "high",
@@ -50,7 +50,7 @@ describe("send-notification tool", () => {
       contextPayload: {
         requestedMessage: "Your verification code is 123456",
         requestedByTool: "send_notification",
-        requestedBySessionId: "conv-1",
+        requestedByContextId: "conv-1",
         requestedTitle: "Verification code",
         requestedByConversationId: "conv-override",
         preferredChannels: ["vellum"],

package/src/__tests__/shell-credential-ref.test.ts

@@ -23,7 +23,6 @@ mock.module("../config/loader.js", () => ({
     ui: {},
 
     timeouts: { shellDefaultTimeoutSec: 120, shellMaxTimeoutSec: 600 },
-    sandbox: { enabled: false, backend: "none" },
     secretDetection: { allowOneTimeSend: false },
   }),
 }));

package/src/__tests__/shell-tool-proxy-mode.test.ts

@@ -34,8 +34,7 @@ const mockConfig = {
     shellMaxTimeoutSec: 600,
     permissionTimeoutSec: 300,
   },
-  sandbox: { enabled: false },
-  rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+  rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
     action: "warn" as const,