@vellumai/assistant 0.12.2 → 0.12.3-staging.1

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

@@ -28,6 +28,9 @@ const MANAGED_PROVIDERS = [
 ] as const;
 
 let platformBaseUrlOverride: string | undefined;
+let platformAssistantIdOverride: string | undefined;
+let platformOrganizationIdOverride: string | undefined;
+let platformUserIdOverride: string | undefined;
 
 mock.module("@google/genai", () => ({
   GoogleGenAI: class MockGoogleGenAI {
@@ -54,9 +57,19 @@ mock.module("@google/genai", () => ({
 
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => PLATFORM_BASE_URL,
+  getPlatformAssistantId: () => platformAssistantIdOverride,
   setPlatformBaseUrl: (value: string | undefined) => {
     platformBaseUrlOverride = value;
   },
+  setPlatformAssistantId: (value: string | undefined) => {
+    platformAssistantIdOverride = value;
+  },
+  setPlatformOrganizationId: (value: string | undefined) => {
+    platformOrganizationIdOverride = value;
+  },
+  setPlatformUserId: (value: string | undefined) => {
+    platformUserIdOverride = value;
+  },
 }));
 
 mock.module("../providers/provider-secret-catalog.js", () => ({
@@ -182,6 +195,9 @@ describe("secret routes managed proxy registry sync", () => {
     metadataDeletes.length = 0;
     lastGeminiConstructorOpts = null;
     platformBaseUrlOverride = undefined;
+    platformAssistantIdOverride = undefined;
+    platformOrganizationIdOverride = undefined;
+    platformUserIdOverride = undefined;
     providerRefreshCalls = 0;
     identitySyncCalls = 0;
     avatarSyncCalls = 0;
@@ -254,32 +270,38 @@ describe("secret routes managed proxy registry sync", () => {
     expect(providerRefreshCalls).toBe(2);
   });
 
-  test("deleting vellum:assistant_api_key clears managed fallback providers immediately", async () => {
+  test("deleting a vellum credential is rejected without touching the vault", async () => {
     secureKeyStore[ASSISTANT_API_KEY_PATH] = "ast-managed-key";
+    secureKeyStore[PLATFORM_BASE_URL_PATH] = "https://managed.example.com";
+    platformBaseUrlOverride = "https://managed.example.com";
+    platformAssistantIdOverride = "asst-1";
     await initializeProviders(getConfig());
 
-    for (const provider of MANAGED_PROVIDERS) {
-      expect(listProviders()).toContain(provider);
-      expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+    for (const name of [
+      "vellum:assistant_api_key",
+      "vellum:platform_base_url",
+      "vellum:webhook_secret",
+      "vellum:platform_assistant_id",
+    ]) {
+      await expect(deleteCredential(name)).rejects.toThrow(
+        "Vellum credentials cannot be deleted",
+      );
     }
 
-    await deleteCredential("vellum:assistant_api_key");
-
-    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBeUndefined();
-    expect(metadataDeletes).toEqual([
-      { service: "vellum", field: "assistant_api_key" },
-    ]);
-    expect(listProviders()).toEqual([]);
+    expect(secureKeyStore[ASSISTANT_API_KEY_PATH]).toBe("ast-managed-key");
+    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBe(
+      "https://managed.example.com",
+    );
+    expect(platformBaseUrlOverride).toBe("https://managed.example.com");
+    expect(platformAssistantIdOverride).toBe("asst-1");
+    expect(metadataDeletes).toEqual([]);
+    expect(providerRefreshCalls).toBe(0);
   });
 
   test("managed proxy credential writes notify live-conversation refresh listeners", async () => {
     await addCredential("vellum:assistant_api_key", "ast-managed-key");
 
     expect(providerRefreshCalls).toBe(1);
-
-    await deleteCredential("vellum:assistant_api_key");
-
-    expect(providerRefreshCalls).toBe(2);
   });
 
   /**
@@ -326,7 +348,6 @@ describe("secret routes managed proxy registry sync", () => {
   test("storing a platform registration credential enqueues name and avatar syncs", async () => {
     for (const name of [
       "vellum:assistant_api_key",
-      "vellum:platform_assistant_id",
       "vellum:platform_base_url",
     ]) {
       identitySyncCalls = 0;
@@ -339,7 +360,6 @@ describe("secret routes managed proxy registry sync", () => {
 
   test("unrelated credentials do not enqueue platform syncs", async () => {
     await addCredential("openrouter:api_key", "openrouter-key");
-    await addCredential("vellum:platform_user_id", "user-1");
 
     expect(identitySyncCalls).toBe(0);
     expect(avatarSyncCalls).toBe(0);
@@ -349,13 +369,61 @@ describe("secret routes managed proxy registry sync", () => {
     failSecureKeyWrites = true;
 
     await expect(
-      addCredential("vellum:platform_assistant_id", "asst-1"),
+      addCredential("vellum:platform_base_url", "https://managed.example.com"),
     ).rejects.toThrow("Failed to store credential");
 
     expect(identitySyncCalls).toBe(0);
     expect(avatarSyncCalls).toBe(0);
   });
 
+  test("unknown vellum credentials are rejected without persisting or binding identity", async () => {
+    platformAssistantIdOverride = "existing-asst";
+    platformOrganizationIdOverride = "existing-org";
+    platformUserIdOverride = "existing-user";
+
+    await expect(
+      addCredential("vellum:platform_assistant_id", "asst-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_assistant_id");
+    await expect(
+      addCredential("vellum:platform_organization_id", "org-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_organization_id");
+    await expect(
+      addCredential("vellum:platform_user_id", "user-1"),
+    ).rejects.toThrow("Unknown vellum credential: platform_user_id");
+
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_assistant_id")],
+    ).toBeUndefined();
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_organization_id")],
+    ).toBeUndefined();
+    expect(
+      secureKeyStore[credentialKey("vellum", "platform_user_id")],
+    ).toBeUndefined();
+    expect(metadataUpserts).toEqual([]);
+    expect(platformAssistantIdOverride).toBe("existing-asst");
+    expect(platformOrganizationIdOverride).toBe("existing-org");
+    expect(platformUserIdOverride).toBe("existing-user");
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
+  test("an unknown vellum credential does not delete leftover vault copies", async () => {
+    const key = credentialKey("vellum", "platform_assistant_id");
+    secureKeyStore[key] = "leftover-asst";
+    platformAssistantIdOverride = "asst-1";
+
+    await expect(
+      addCredential("vellum:platform_assistant_id", "   "),
+    ).rejects.toThrow("Unknown vellum credential: platform_assistant_id");
+
+    expect(secureKeyStore[key]).toBe("leftover-asst");
+    expect(platformAssistantIdOverride).toBe("asst-1");
+    expect(metadataDeletes).toEqual([]);
+    expect(identitySyncCalls).toBe(0);
+    expect(avatarSyncCalls).toBe(0);
+  });
+
   test("storing vellum:platform_base_url sets override and triggers initializeProviders", async () => {
     await addCredential(
       "vellum:platform_base_url",
@@ -389,17 +457,4 @@ describe("secret routes managed proxy registry sync", () => {
       expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
     }
   });
-
-  test("deleting vellum:platform_base_url clears override and re-initializes providers", async () => {
-    secureKeyStore[PLATFORM_BASE_URL_PATH] = "https://managed.example.com";
-    platformBaseUrlOverride = "https://managed.example.com";
-
-    await deleteCredential("vellum:platform_base_url");
-
-    expect(secureKeyStore[PLATFORM_BASE_URL_PATH]).toBeUndefined();
-    expect(platformBaseUrlOverride).toBeUndefined();
-    expect(metadataDeletes).toEqual([
-      { service: "vellum", field: "platform_base_url" },
-    ]);
-  });
 });

package/src/__tests__/secret-routes-scrub.test.ts

@@ -222,39 +222,34 @@ describe("secrets_add credential transcript scrub", () => {
     expect(scrubbedValues).toEqual([CREDENTIAL_VALUE]);
   });
 
-  test("non-secret platform fields are stored but never scrubbed", async () => {
-    for (const field of [
-      "platform_assistant_id",
-      "platform_organization_id",
-      "platform_user_id",
-      "platform_base_url",
-    ]) {
-      const result = await addRoute.handler({
-        body: {
-          type: "credential",
-          name: `vellum:${field}`,
-          value: "0198f4c2-1111-2222-3333-444455556666",
-        },
-      });
-      expect(result).toEqual(expect.objectContaining({ success: true }));
-    }
-
-    // All four stored, none scrubbed — they are benign UUIDs/URLs that
-    // legitimately appear in transcripts.
-    expect(secureStore.size).toBe(4);
-    expect(scrubbedValues).toEqual([]);
-  });
-
-  test("an identity-field delete stores nothing and never scrubs", async () => {
+  test("non-secret platform fields are not scrubbed", async () => {
     const result = await addRoute.handler({
       body: {
         type: "credential",
-        name: "vellum:platform_assistant_id",
-        value: "   ",
+        name: "vellum:platform_base_url",
+        value: "0198f4c2-1111-2222-3333-444455556666",
       },
     });
-
     expect(result).toEqual(expect.objectContaining({ success: true }));
+
+    expect(secureStore.size).toBe(1);
+    expect(secureStore.get(credentialKey("vellum", "platform_base_url"))).toBe(
+      "0198f4c2-1111-2222-3333-444455556666",
+    );
+    expect(scrubbedValues).toEqual([]);
+  });
+
+  test("an unknown vellum credential is rejected and never triggers a scrub", async () => {
+    await expect(
+      addRoute.handler({
+        body: {
+          type: "credential",
+          name: "vellum:platform_assistant_id",
+          value: "   ",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+
     expect(secureStore.size).toBe(0);
     expect(scrubbedValues).toEqual([]);
   });

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

@@ -187,6 +187,26 @@ describe("Anthropic keys", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Resend
+// ---------------------------------------------------------------------------
+describe("Resend keys", () => {
+  const key = `re_${"a".repeat(8)}_${"b".repeat(24)}`;
+
+  test("detects re_ key", () => {
+    expectMatch(key, "Resend API Key");
+  });
+
+  test("redacts a key echoed from shell output", () => {
+    const out = redactSecrets(`$ cat .env\nRESEND=${key}\n`);
+    expect(out).not.toContain(key);
+  });
+
+  test("ignores re_ identifiers that are not key-shaped", () => {
+    expectNoMatch("re_0_of_1_is_deprecated_6387");
+  });
+});
+
 // ---------------------------------------------------------------------------
 // OpenAI
 // ---------------------------------------------------------------------------

package/src/__tests__/secure-keys-managed-failover.test.ts

@@ -63,4 +63,12 @@ describe("secure-keys managed CES failover", () => {
     expect(rpcCall).toHaveBeenCalledTimes(1);
     expect(globalThis.fetch).toHaveBeenCalledTimes(1);
   });
+
+  test("uses CES HTTP only after lazy IPC finds no socket", async () => {
+    const start = Date.now();
+    expect(await getSecureKeyAsync("openai")).toBe("http-secret");
+    expect(Date.now() - start).toBeLessThan(1_000);
+    expect(getActiveBackendName()).toBe("ces-http");
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+  });
 });

package/src/__tests__/secure-keys.test.ts

@@ -61,7 +61,6 @@ describe("secure-keys", () => {
     delete process.env.VELLUM_DESKTOP_APP;
     delete process.env.IS_CONTAINERIZED;
     delete process.env.CES_CREDENTIAL_URL;
-    delete process.env.CES_LOCAL_SOCKET;
   });
 
   afterAll(() => {
@@ -79,6 +78,13 @@ describe("secure-keys", () => {
       expect(await getSecureKeyAsync("openai")).toBe("sk-openai-789");
     });
 
+    test("does not poll for a CES socket when none is present", async () => {
+      const start = Date.now();
+      await getSecureKeyAsync("openai");
+      expect(Date.now() - start).toBeLessThan(1_000);
+      expect(getActiveBackendName()).toBe("encrypted-store");
+    });
+
     test("get returns undefined for nonexistent key", async () => {
       expect(await getSecureKeyAsync("nonexistent")).toBeUndefined();
     });
@@ -552,7 +558,6 @@ describe("secure-keys", () => {
     test("reads report unreachable (indeterminate), never absent", async () => {
       process.env.IS_CONTAINERIZED = "1";
       delete process.env.CES_CREDENTIAL_URL;
-      delete process.env.CES_LOCAL_SOCKET;
       _resetBackend();
 
       const result = await getSecureKeyResultAsync("openai");
@@ -564,7 +569,6 @@ describe("secure-keys", () => {
     test("does not pin the unreachable result: a ready CES client wins the next read", async () => {
       process.env.IS_CONTAINERIZED = "1";
       delete process.env.CES_CREDENTIAL_URL;
-      delete process.env.CES_LOCAL_SOCKET;
       _resetBackend();
 
       expect((await getSecureKeyResultAsync("openai")).unreachable).toBe(true);

package/src/__tests__/server-tool-pairing.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+
+import { analyzeServerToolPairing } from "../providers/server-tool-pairing.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+const DEFERRED_ID = "srvtoolu_deferred";
+
+const opener: Message = {
+  role: "user",
+  content: [{ type: "text", text: "Check both" }],
+};
+
+/** Assistant turn calling a client tool and a native web search together. */
+const mixedTail: Message = {
+  role: "assistant",
+  content: [
+    { type: "tool_use", id: "tu_a", name: "web_fetch", input: {} },
+    {
+      type: "server_tool_use",
+      id: DEFERRED_ID,
+      name: "web_search",
+      input: { query: "news" },
+    },
+  ],
+};
+
+const clientResult: ContentBlock = {
+  type: "tool_result",
+  tool_use_id: "tu_a",
+  content: "Error: HTTP 404",
+  is_error: true,
+};
+
+const guidance: ContentBlock = {
+  type: "text",
+  text: "<system_notice>retry</system_notice>",
+};
+
+describe("analyzeServerToolPairing", () => {
+  test("an unanswered use with nothing after it is deferred", () => {
+    const pairing = analyzeServerToolPairing([opener, mixedTail]);
+
+    expect(pairing.deferredUseIds).toEqual(new Set([DEFERRED_ID]));
+    expect(pairing.resolvedPairIds.size).toBe(0);
+  });
+
+  test("an unanswered use answered by tool_result blocks alone is deferred", () => {
+    const pairing = analyzeServerToolPairing([
+      opener,
+      mixedTail,
+      { role: "user", content: [clientResult] },
+    ]);
+
+    expect(pairing.deferredUseIds).toEqual(new Set([DEFERRED_ID]));
+  });
+
+  test("guidance text after the tool_result makes the use an orphan, not a deferral", () => {
+    // The trailing text closes the assistant turn on the provider side, which
+    // then rejects the unanswered use as unpaired; the repair passes stamp a
+    // synthetic result instead of preserving it.
+    const pairing = analyzeServerToolPairing([
+      opener,
+      mixedTail,
+      { role: "user", content: [clientResult, guidance] },
+    ]);
+
+    expect(pairing.deferredUseIds.size).toBe(0);
+    expect(pairing.resolvedPairIds.size).toBe(0);
+  });
+
+  test("a user text message after the tool_result message makes the use an orphan", () => {
+    const pairing = analyzeServerToolPairing([
+      opener,
+      mixedTail,
+      { role: "user", content: [clientResult] },
+      { role: "user", content: [{ type: "text", text: "also do this" }] },
+    ]);
+
+    expect(pairing.deferredUseIds.size).toBe(0);
+  });
+
+  test("a use answered in its own message is resolved and never deferred", () => {
+    const pairing = analyzeServerToolPairing([
+      opener,
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "srvtoolu_done",
+            name: "web_search",
+            input: { query: "news" },
+          },
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srvtoolu_done",
+            content: [],
+          },
+        ],
+      },
+      { role: "user", content: [guidance] },
+    ]);
+
+    expect(pairing.resolvedPairIds).toEqual(new Set(["srvtoolu_done"]));
+    expect(pairing.deferredUseIds.size).toBe(0);
+  });
+});

package/src/__tests__/skills.test.ts

@@ -1054,14 +1054,15 @@ describe("ingress-dependent setup skills declare public-ingress intentionally",
     expect(includes ?? []).not.toContain("public-ingress");
   });
 
-  test("telegram-setup documents the private-chat limitation", () => {
+  test("telegram-setup documents which chats are supported and how a group is addressed", () => {
     const content = readFileSync(
       join(FIRST_PARTY_SKILLS_DIR, "telegram-setup", "SKILL.md"),
       "utf-8",
     );
-    expect(content).toMatch(/private-chat only/i);
-    expect(content).toMatch(/group, supergroup, and channel/i);
-    expect(content).toMatch(/button taps/i);
+    expect(content).toMatch(/private chats and in groups and supergroups/i);
+    expect(content).toMatch(/@mention of the bot's username/i);
+    expect(content).toMatch(/reply to one of its posts/i);
+    expect(content).toMatch(/Broadcast channels are not supported/i);
   });
 
   test("twilio-setup includes public-ingress", () => {