@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/runtime-events-sse.test.ts

@@ -129,7 +129,7 @@ describe("SSE assistant-events endpoint", () => {
 
     // start() is called synchronously during ReadableStream construction, so the
     // hub subscription is already registered before we publish.
-    const event = buildAssistantEvent("self", { type: "pong" }, conversationId);
+    const event = buildAssistantEvent({ type: "pong" }, conversationId);
     await assistantEventHub.publish(event);
 
     // Read the first frame directly from the stream.
@@ -147,7 +147,6 @@ describe("SSE assistant-events endpoint", () => {
     expect(done).toBe(false);
     const frame = new TextDecoder().decode(value);
     expect(frame).toContain("event: assistant_event");
-    expect(frame).toContain(`"assistantId":"self"`);
     expect(frame).toContain(`"conversationId":"${conversationId}"`);
     expect(frame).toContain('"type":"pong"');
   });
@@ -177,16 +176,8 @@ describe("SSE assistant-events endpoint", () => {
     expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
 
     // Publish events with two different conversationIds.
-    const eventA = buildAssistantEvent(
-      "self",
-      { type: "pong" },
-      "conversation-aaa",
-    );
-    const eventB = buildAssistantEvent(
-      "self",
-      { type: "pong" },
-      "conversation-bbb",
-    );
+    const eventA = buildAssistantEvent({ type: "pong" }, "conversation-aaa");
+    const eventB = buildAssistantEvent({ type: "pong" }, "conversation-bbb");
     await testHub.publish(eventA);
     await testHub.publish(eventB);
 

package/src/__tests__/search-skills-unified.test.ts

@@ -165,12 +165,6 @@ import { searchSkills } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-const dummyCtx = {
-  debounceTimers: { schedule: () => {} },
-  setSuppressConfigReload: () => {},
-  updateConfigFingerprint: () => {},
-  broadcast: () => {},
-} as unknown as Parameters<typeof searchSkills>[1];
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -224,7 +218,7 @@ describe("searchSkills (unified)", () => {
       },
     ]);
 
-    const result = await searchSkills("e", dummyCtx);
+    const result = await searchSkills("e");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -284,7 +278,7 @@ describe("searchSkills (unified)", () => {
       },
     ]);
 
-    const result = await searchSkills("shared", dummyCtx);
+    const result = await searchSkills("shared");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -326,7 +320,7 @@ describe("searchSkills (unified)", () => {
       },
     ]);
 
-    const result = await searchSkills("overlap", dummyCtx);
+    const result = await searchSkills("overlap");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -357,7 +351,7 @@ describe("searchSkills (unified)", () => {
     });
     mockSkillsshSearch.mockRejectedValue(new Error("skills.sh is down"));
 
-    const result = await searchSkills("clawhub", dummyCtx);
+    const result = await searchSkills("clawhub");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -379,7 +373,7 @@ describe("searchSkills (unified)", () => {
       },
     ]);
 
-    const result = await searchSkills("skillssh", dummyCtx);
+    const result = await searchSkills("skillssh");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -400,7 +394,7 @@ describe("searchSkills (unified)", () => {
     mockClawhubSearch.mockRejectedValue(new Error("clawhub down"));
     mockSkillsshSearch.mockRejectedValue(new Error("skillssh down"));
 
-    const result = await searchSkills("my", dummyCtx);
+    const result = await searchSkills("my");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -422,7 +416,7 @@ describe("searchSkills (unified)", () => {
       },
     ]);
 
-    const result = await searchSkills("test", dummyCtx);
+    const result = await searchSkills("test");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -474,7 +468,7 @@ describe("searchSkills (unified)", () => {
       },
     });
 
-    const result = await searchSkills("lint", dummyCtx);
+    const result = await searchSkills("lint");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 
@@ -526,7 +520,7 @@ describe("searchSkills (unified)", () => {
     ]);
     mockFetchSkillAudits.mockRejectedValue(new Error("audit service down"));
 
-    const result = await searchSkills("my-skill", dummyCtx);
+    const result = await searchSkills("my-skill");
     expect(result.success).toBe(true);
     if (!result.success) throw new Error("Expected success");
 

package/src/__tests__/secret-ingress-cli.test.ts

@@ -25,11 +25,8 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Test: CLI signal path uses registerUserMessageCallback which calls
-// checkIngressForSecrets before calling persistAndProcessMessage.
-//
-// We test the callback behavior directly rather than the full signal file
-// flow, since the signal handler is just file I/O around the callback.
+// Test: CLI signal path (user-message signal handler) calls
+// checkIngressForSecrets before dispatching through processMessageInBackground.
 // ---------------------------------------------------------------------------
 
 import { resetAllowlist } from "../security/secret-allowlist.js";

package/src/__tests__/secret-ingress-http.test.ts

@@ -211,11 +211,7 @@ function makeSendMessageDeps() {
     assistantId: "self",
     trustContext: undefined,
     hasPendingConfirmation: () => false,
-    setHostBashProxy: () => {},
     setHostBrowserProxy: () => {},
-    setHostFileProxy: () => {},
-    setHostTransferProxy: () => {},
-    getHostTransferProxy: () => undefined,
     setHostCuProxy: () => {},
     addPreactivatedSkillId: () => {},
   } as unknown as import("../daemon/conversation.js").Conversation;

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

@@ -7,8 +7,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 const mockConfig = {
   secretDetection: {
     enabled: true,
-    action: "block" as "redact" | "warn" | "block",
-    entropyThreshold: 4.0,
     allowOneTimeSend: false,
   },
   timeouts: { permissionTimeoutSec: 300 },
@@ -63,6 +61,10 @@ mock.module("../security/secure-keys.js", () => {
   };
   return {
     getSecureKeyAsync: async (key: string) => storedKeys.get(key) ?? undefined,
+    getSecureKeyResultAsync: async (account: string) => ({
+      value: storedKeys.get(account),
+      unreachable: false,
+    }),
     setSecureKeyAsync: async (key: string, value: string) =>
       syncSet(key, value),
     deleteSecureKeyAsync: async (key: string) => syncDelete(key),

package/src/__tests__/secret-prompt-log-hygiene.test.ts

@@ -30,6 +30,26 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
+// Capture broadcastMessage calls
+const broadcastedMessages: ServerMessage[] = [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => {
+    broadcastedMessages.push(msg);
+  },
+}));
+
+// Stub pendingInteractions — SecretPrompter registers/resolves there now
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => {},
+  resolve: () => undefined,
+  get: () => undefined,
+  getAll: () => [],
+  getByConversation: () => [],
+  getByKind: () => [],
+  removeByConversation: () => {},
+  clear: () => {},
+}));
+
 // Use a tiny timeout so the setTimeout branch fires quickly in tests
 const mockConfig = {
   timeouts: { permissionTimeoutSec: 0.01 },
@@ -51,20 +71,17 @@ function logContainsValue(secret: string): boolean {
 
 describe("secret prompt log hygiene", () => {
   let prompter: InstanceType<typeof SecretPrompter>;
-  let sentMessages: ServerMessage[];
 
   beforeEach(() => {
     logCalls.length = 0;
-    sentMessages = [];
-    prompter = new SecretPrompter((msg) => {
-      sentMessages.push(msg);
-    });
+    broadcastedMessages.length = 0;
+    prompter = new SecretPrompter();
   });
 
   test("resolveSecret never logs the secret value", async () => {
     const secret = "sv42";
     const promise = prompter.prompt("myservice", "apikey", "API Key");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, secret, "store");
     const result = await promise;
 
@@ -105,7 +122,7 @@ describe("secret prompt log hygiene", () => {
 
   test("sent message contains value=undefined (value flows through event, not logs)", async () => {
     const promise = prompter.prompt("svc", "tok", "Token");
-    const msg = sentMessages[0] as SecretRequest & { value?: unknown };
+    const msg = broadcastedMessages[0] as SecretRequest & { value?: unknown };
     // The message should NOT contain a value field
     expect(msg.value).toBeUndefined();
     prompter.resolveSecret(msg.requestId, undefined);

package/src/__tests__/secret-prompter-channel-fallback.test.ts

@@ -33,37 +33,31 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
+let broadcastMessages: ServerMessage[] = [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => broadcastMessages.push(msg),
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => {},
+  resolve: () => undefined,
+  get: () => undefined,
+  getAll: () => [],
+  getByConversation: () => [],
+  getByKind: () => [],
+  removeByConversation: () => {},
+  clear: () => {},
+}));
+
 const { SecretPrompter } = await import("../permissions/secret-prompter.js");
 
 describe("secret prompter channel fallback", () => {
-  let sentMessages: ServerMessage[];
-  let broadcastMessages: ServerMessage[];
-
   beforeEach(() => {
-    sentMessages = [];
     broadcastMessages = [];
   });
 
-  test("fails fast with unsupported_channel error when channel lacks dynamic UI and no broadcast available", async () => {
-    const prompter = new SecretPrompter((msg) => sentMessages.push(msg));
-    prompter.setChannelContext({
-      channel: "slack",
-      supportsDynamicUi: false,
-    });
-
-    const result = await prompter.prompt("myservice", "apikey", "API Key");
-
-    expect(result.value).toBeNull();
-    expect(result.error).toBe("unsupported_channel");
-    // No message should have been sent since we failed fast
-    expect(sentMessages).toHaveLength(0);
-  });
-
-  test("broadcasts secret_request via SSE hub when channel lacks dynamic UI but broadcast is available", async () => {
-    const prompter = new SecretPrompter(
-      (msg) => sentMessages.push(msg),
-      (msg) => broadcastMessages.push(msg),
-    );
+  test("broadcasts secret_request when channel lacks dynamic UI", async () => {
+    const prompter = new SecretPrompter();
     prompter.setChannelContext({
       channel: "slack",
       supportsDynamicUi: false,
@@ -71,24 +65,17 @@ describe("secret prompter channel fallback", () => {
 
     const promise = prompter.prompt("myservice", "apikey", "API Key");
 
-    // Should have broadcast the message, not sent via per-channel sender
-    expect(sentMessages).toHaveLength(0);
     expect(broadcastMessages).toHaveLength(1);
     expect(broadcastMessages[0]!.type).toBe("secret_request");
 
-    // Resolve the prompt so it doesn't hang
     const requestId = (broadcastMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "test-secret", "store");
     const result = await promise;
     expect(result.value).toBe("test-secret");
-    expect(result.error).toBeUndefined();
   });
 
-  test("uses sendToClient when channel supports dynamic UI", async () => {
-    const prompter = new SecretPrompter(
-      (msg) => sentMessages.push(msg),
-      (msg) => broadcastMessages.push(msg),
-    );
+  test("broadcasts secret_request when channel supports dynamic UI", async () => {
+    const prompter = new SecretPrompter();
     prompter.setChannelContext({
       channel: "macos",
       supportsDynamicUi: true,
@@ -96,30 +83,38 @@ describe("secret prompter channel fallback", () => {
 
     const promise = prompter.prompt("myservice", "apikey", "API Key");
 
-    // Should use per-channel sender, not broadcast
-    expect(sentMessages).toHaveLength(1);
-    expect(broadcastMessages).toHaveLength(0);
-    expect(sentMessages[0]!.type).toBe("secret_request");
+    expect(broadcastMessages).toHaveLength(1);
+    expect(broadcastMessages[0]!.type).toBe("secret_request");
 
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "test-secret", "store");
     await promise;
   });
 
-  test("uses sendToClient when no channel context is set (desktop default)", async () => {
-    const prompter = new SecretPrompter(
-      (msg) => sentMessages.push(msg),
-      (msg) => broadcastMessages.push(msg),
-    );
-    // No setChannelContext call — desktop default
+  test("broadcasts secret_request when no channel context is set (desktop default)", async () => {
+    const prompter = new SecretPrompter();
 
     const promise = prompter.prompt("myservice", "apikey", "API Key");
 
-    expect(sentMessages).toHaveLength(1);
-    expect(broadcastMessages).toHaveLength(0);
+    expect(broadcastMessages).toHaveLength(1);
+    expect(broadcastMessages[0]!.type).toBe("secret_request");
 
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "val", "store");
     await promise;
   });
+
+  test("resolveSecret cleans up pending state", async () => {
+    const prompter = new SecretPrompter();
+
+    const promise = prompter.prompt("myservice", "apikey", "API Key");
+    const requestId = (broadcastMessages[0] as SecretRequest).requestId;
+
+    expect(prompter.hasPendingRequest(requestId)).toBe(true);
+
+    prompter.resolveSecret(requestId, "secret", "store");
+    expect(prompter.hasPendingRequest(requestId)).toBe(false);
+
+    await promise;
+  });
 });

package/src/__tests__/secret-response-routing.test.ts

@@ -1,26 +1,40 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   SecretRequest,
   ServerMessage,
 } from "../daemon/message-protocol.js";
 import type { SecretPromptResult } from "../permissions/secret-prompter.js";
-import { SecretPrompter } from "../permissions/secret-prompter.js";
+
+let broadcastedMessages: ServerMessage[] = [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => {},
+  resolve: () => undefined,
+  get: () => undefined,
+  getAll: () => [],
+  getByConversation: () => [],
+  getByKind: () => [],
+  removeByConversation: () => {},
+  clear: () => {},
+}));
+
+const { SecretPrompter } = await import("../permissions/secret-prompter.js");
 
 describe("secret response routing", () => {
-  let prompter: SecretPrompter;
-  let sentMessages: ServerMessage[];
+  let prompter: InstanceType<typeof SecretPrompter>;
 
   beforeEach(() => {
-    sentMessages = [];
-    prompter = new SecretPrompter((msg) => {
-      sentMessages.push(msg);
-    });
+    broadcastedMessages = [];
+    prompter = new SecretPrompter();
   });
 
   test("resolveSecret defaults delivery to store when omitted", async () => {
     const promise = prompter.prompt("github", "token", "GitHub Token");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "test-value");
     const result: SecretPromptResult = await promise;
     expect(result.value).toBe("test-value");
@@ -29,7 +43,7 @@ describe("secret response routing", () => {
 
   test("resolveSecret passes store delivery", async () => {
     const promise = prompter.prompt("github", "token", "GitHub Token");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "test-value", "store");
     const result = await promise;
     expect(result.value).toBe("test-value");
@@ -38,7 +52,7 @@ describe("secret response routing", () => {
 
   test("resolveSecret passes transient_send delivery", async () => {
     const promise = prompter.prompt("github", "token", "GitHub Token");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, "one-time-value", "transient_send");
     const result = await promise;
     expect(result.value).toBe("one-time-value");
@@ -47,7 +61,7 @@ describe("secret response routing", () => {
 
   test("resolveSecret with cancelled value defaults delivery to store", async () => {
     const promise = prompter.prompt("github", "token", "GitHub Token");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, undefined);
     const result = await promise;
     expect(result.value).toBeNull();
@@ -58,7 +72,7 @@ describe("secret response routing", () => {
     // We can't easily test the full timeout, but we verify the structure
     // by resolving immediately (the timeout path also returns { value: null, delivery: 'store' })
     const promise = prompter.prompt("github", "token", "GitHub Token");
-    const requestId = (sentMessages[0] as SecretRequest).requestId;
+    const requestId = (broadcastedMessages[0] as SecretRequest).requestId;
     prompter.resolveSecret(requestId, undefined, undefined);
     const result = await promise;
     expect(result.value).toBeNull();
@@ -74,8 +88,8 @@ describe("secret response routing", () => {
       "placeholder",
       "session-1",
     );
-    expect(sentMessages.length).toBe(1);
-    const msg = sentMessages[0] as SecretRequest;
+    expect(broadcastedMessages.length).toBe(1);
+    const msg = broadcastedMessages[0] as SecretRequest;
     expect(msg.type).toBe("secret_request");
     expect(msg.service).toBe("github");
     expect(msg.field).toBe("token");

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

@@ -77,6 +77,10 @@ mock.module("../config/loader.js", () => ({
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (key: string) => secureKeyStore[key],
+  getSecureKeyResultAsync: async (key: string) => ({
+    value: secureKeyStore[key],
+    unreachable: false,
+  }),
   setSecureKeyAsync: async (key: string, value: string) => {
     secureKeyStore[key] = value;
     return true;
@@ -187,7 +191,7 @@ describe("secret routes managed proxy registry sync", () => {
   test("provider API key writes notify live-conversation refresh listeners", async () => {
     await addApiKey("fireworks", "fw-key");
 
-    expect(secureKeyStore.fireworks).toBe("fw-key");
+    expect(secureKeyStore[credentialKey("fireworks", "api_key")]).toBe("fw-key");
     expect(providerRefreshCalls).toBe(1);
 
     await deleteApiKey("fireworks");