@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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

@@ -12,6 +12,11 @@ mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
+import {
+  type MessagingConversationContext,
+  persistUserMessage,
+} from "../daemon/conversation-messaging.js";
+import { ConversationModeSessionCoordinator } from "../daemon/conversation-mode-session.js";
 import {
   getConversationByKey,
   getOrCreateConversation,
@@ -91,6 +96,7 @@ import {
   bridgeState,
   gatewayGuardianRequestsStoreBridge,
 } from "./helpers/gateway-guardian-requests-store-bridge.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 mock.module(
   "../channels/gateway-guardian-requests.js",
@@ -99,7 +105,7 @@ mock.module(
 
 import type { AssistantEventEnvelope } from "../api/index.js";
 import { __resetGuardianDeliveryCacheForTest } from "../contacts/guardian-delivery-reader.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import type { ApprovalConversationGenerator } from "../runtime/http-types.js";
@@ -116,6 +122,7 @@ function makeCompletingConversation(): Conversation {
   let processing = false;
   const messages: unknown[] = [];
   return {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
@@ -166,6 +173,7 @@ function makeHangingConversation(): Conversation {
     requestId?: string;
   }> = [];
   return {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
@@ -244,6 +252,7 @@ function makePendingApprovalConversation(
   });
 
   const conversation = {
+    modeSessions: mockUnownedModeSessions(),
     isProcessing: () => processing,
     persistUserMessage: (options: { requestId?: string }) => ({
       id: options.requestId ?? "msg-1",
@@ -346,6 +355,159 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
 
   // ── Idle conversation: immediate processing ─────────────────────────
 
+  test.each([
+    { failure: "acceptTurn", surface: false },
+    { failure: "trackPersistedRow", surface: false },
+    { failure: "acceptTurn", surface: true },
+    { failure: "trackPersistedRow", surface: true },
+  ] as const)(
+    "dispatches committed content once despite $failure failure (surface=$surface)",
+    async ({ failure, surface }) => {
+      const conversationKey = "conv-tracking-failure";
+      const { conversationId } = getOrCreateConversation(conversationKey);
+      const modeSessions = new ConversationModeSessionCoordinator(
+        conversationId,
+      );
+      const source = surface
+        ? modeSessions.activateSource({
+            sourceId: "browser-source",
+            generation: 1,
+            mode: "browser",
+            sourceStartedAt: 100,
+          })!
+        : undefined;
+      if (source) {
+        modeSessions.claimTurn("turn-origin", source, 110);
+        modeSessions.recordStructuralWait("turn-origin", {
+          kind: "surface",
+          responseId: "surface-123",
+        });
+        modeSessions.releaseTurn("turn-origin");
+      }
+
+      const persistedRows = () =>
+        getSqlite()
+          .query<
+            { id: string; content: string },
+            [string]
+          >("SELECT id, content FROM messages WHERE conversation_id = ? AND role = 'user'")
+          .all(conversationId);
+      const acceptTurn = modeSessions.acceptTurn.bind(modeSessions);
+      const trackPersistedRow =
+        modeSessions.trackPersistedRow.bind(modeSessions);
+      const committedCounts: number[] = [];
+      const trackingFailure = mock(() => {
+        committedCounts.push(persistedRows().length);
+        throw new Error("optional session tracking failed");
+      });
+      modeSessions.acceptTurn = (...args) => {
+        const owner = acceptTurn(...args);
+        if (failure === "acceptTurn") {
+          trackingFailure();
+        }
+        return owner;
+      };
+      modeSessions.trackPersistedRow = (...args) => {
+        trackPersistedRow(...args);
+        if (failure === "trackPersistedRow") {
+          trackingFailure();
+        }
+      };
+
+      let processing = false;
+      let processingOwner = 0;
+      const releases: number[] = [];
+      const ctx = Object.assign(makeCompletingConversation(), {
+        conversationId,
+        modeSessions,
+        messages: [],
+        abortController: null as AbortController | null,
+        currentRequestId: undefined as string | undefined,
+        currentTurnClientMessageId: undefined as string | undefined,
+        currentActiveSurfaceId: surface ? "surface-123" : undefined,
+        inFlightSendRequestIds: new Map<string, string>(),
+        isProcessing: () => processing,
+        acquireProcessingFenced: async () => {
+          processing = true;
+          return ++processingOwner;
+        },
+        releaseProcessing: (owner: number) => {
+          releases.push(owner);
+          processing = false;
+          return true;
+        },
+        getTurnChannelContext: () => null,
+        getTurnInterfaceContext: () => null,
+      });
+      ctx.persistUserMessage = (options) =>
+        persistUserMessage(
+          ctx as unknown as MessagingConversationContext,
+          options,
+        );
+      const runAgentLoop = mock(async (_content: string, messageId: string) => {
+        expect(ctx.isProcessing()).toBe(true);
+        expect(ctx.messages).toHaveLength(1);
+        expect(modeSessions.getTurnOwner(messageId)?.id).toBe(source?.id);
+        modeSessions.releaseTurn(messageId, {
+          status: "completed",
+          endReason: "turn_complete",
+        });
+        ctx.releaseProcessing(processingOwner);
+        ctx.currentRequestId = undefined;
+        ctx.currentTurnClientMessageId = undefined;
+        ctx.abortController = null;
+      });
+      ctx.runAgentLoop = runAgentLoop;
+      await startServer(() => ctx);
+
+      const send = () =>
+        fetch(messagesUrl(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+          body: JSON.stringify({
+            conversationKey,
+            content: "Continue the task",
+            clientMessageId: "client-message-123",
+            sourceChannel: "vellum",
+            interface: "macos",
+          }),
+        });
+      const first = await send();
+      const firstBody = (await first.json()) as {
+        accepted: boolean;
+        messageId: string;
+      };
+      expect(first.status).toBe(202);
+      expect(firstBody.accepted).toBe(true);
+      expect(runAgentLoop).toHaveBeenCalledTimes(1);
+      await runAgentLoop.mock.results[0]!.value;
+      expect(trackingFailure).toHaveBeenCalledTimes(1);
+      expect(committedCounts).toEqual([1]);
+
+      const retry = await send();
+      expect(retry.status).toBe(202);
+      expect(await retry.json()).toMatchObject(firstBody);
+      expect(runAgentLoop).toHaveBeenCalledTimes(1);
+      expect(trackingFailure).toHaveBeenCalledTimes(1);
+      expect(persistedRows()).toEqual([
+        {
+          id: firstBody.messageId,
+          content: JSON.stringify([
+            { type: "text", text: "Continue the task" },
+          ]),
+        },
+      ]);
+      expect(ctx.messages).toHaveLength(1);
+      expect(ctx.isProcessing()).toBe(false);
+      expect(ctx.abortController).toBeNull();
+      expect(ctx.currentRequestId).toBeUndefined();
+      expect(ctx.currentTurnClientMessageId).toBeUndefined();
+      expect(releases).toEqual([1, 2]);
+      expect(modeSessions.getTurnOwner(firstBody.messageId)).toBeUndefined();
+      expect(modeSessions.hasResidentWork()).toBe(false);
+    },
+  );
+
   test("returns 202 with accepted: true and messageId when conversation is idle", async () => {
     await startServer(() => makeCompletingConversation());
 

package/src/__tests__/server-history-render.test.ts

@@ -1,8 +1,11 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import type { AnsweredQuestion } from "../api/events/question-answered.js";
+import type {
+  ToolActivityMetadata,
+  WebFetchMetadata,
+} from "../api/events/tool-result.js";
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import {
   getAttachmentsForMessage,
   linkAttachmentToMessage,
@@ -675,6 +678,93 @@ describe("renderHistoryContent", () => {
     expect(output.toolCalls[0].activityMetadata).toBeUndefined();
   });
 
+  test("hydrates persisted recall and remember activity", () => {
+    const recall: ToolActivityMetadata = {
+      recall: {
+        query: "launch plan",
+        depth: "standard",
+        sources: ["memory", "workspace"],
+        answer: "The launch moved to Friday.",
+        evidence: [
+          {
+            source: "workspace",
+            title: "notes/launch.md",
+            locator: "notes/launch.md:4",
+            excerpt: "Launch moves to Friday.",
+          },
+        ],
+        searchedSources: [
+          { source: "memory", status: "searched", evidenceCount: 0 },
+          {
+            source: "workspace",
+            status: "degraded",
+            evidenceCount: 1,
+            error: "index stale",
+          },
+        ],
+      },
+    };
+    const remember: ToolActivityMetadata = {
+      remember: { facts: ["Prefers window seats"] },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "recall",
+        input: { query: "launch plan" },
+        _activityMetadata: recall,
+      },
+      {
+        type: "tool_use",
+        id: "tu_2",
+        name: "remember",
+        input: { content: "Prefers window seats" },
+        _activityMetadata: remember,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(recall);
+    expect(output.toolCalls[1].activityMetadata).toEqual(remember);
+  });
+
+  test("drops a malformed activity entry and keeps a valid sibling", () => {
+    const webFetch: WebFetchMetadata = {
+      url: "https://example.com",
+      finalUrl: "https://example.com",
+      status: 200,
+      byteCount: 1024,
+      charCount: 900,
+      truncated: false,
+      domain: "example.com",
+      redirectCount: 0,
+      durationMs: 40,
+    };
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_fetch",
+        input: { url: "https://example.com" },
+        _activityMetadata: {
+          webSearch: { query: "x", results: "not a list" },
+          webFetch,
+        },
+      },
+      {
+        type: "server_tool_use",
+        id: "tu_2",
+        name: "web_search",
+        input: { query: "x" },
+        _activityMetadata: { webSearch: { query: 42 } },
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual({ webFetch });
+    expect(output.toolCalls[1].activityMetadata).toBeUndefined();
+  });
+
   test("ignores non-array _risk*Options annotations", () => {
     // Defensive: a malformed persisted block should not throw or coerce.
     const output = renderHistoryContent([

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__/settings-routes.test.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 
 // Guardian identity resolves via the gateway delivery cache, not the local
 // contacts DB. Seed it per-test via seedGatewayGuardian; persona resolution
@@ -42,17 +42,66 @@ function seedGatewayGuardian(g: {
   gatewayGuardians.push({ status: "active", ...g });
 }
 
+import {
+  getBundledSkillsDir,
+  type SkillToolManifest,
+} from "../config/skills.js";
+import * as permissions from "../permissions/checker.js";
+import { RiskLevel } from "../permissions/types.js";
 import { getSqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/settings-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { registerSkillTools, unregisterSkillTools } from "../tools/registry.js";
+import { createSkillToolsFromManifest } from "../tools/skills/skill-tool-factory.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 await initializeDb();
 
 const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
 
+test("permission simulation resolves the bundled computer-use target from input", async () => {
+  const classify = spyOn(permissions, "classifyRisk").mockResolvedValue({
+    level: RiskLevel.Low,
+    reason: "Test classification",
+    matchType: "registry",
+    scopeOptions: [],
+  });
+  const check = spyOn(permissions, "check").mockResolvedValue({
+    decision: "allow",
+    reason: "Test decision",
+  });
+  const skillDir = join(getBundledSkillsDir(), "computer-use");
+  const manifest = JSON.parse(
+    readFileSync(join(skillDir, "TOOLS.json"), "utf8"),
+  ) as SkillToolManifest;
+  const skillId = "simulation-computer-use";
+  registerSkillTools(
+    skillId,
+    createSkillToolsFromManifest(manifest.tools, skillDir, "", true),
+  );
+  try {
+    for (const target of ["assistant-desktop", "connected-computer"]) {
+      const result = await getHandler(
+        "tools/simulate-permission",
+        "POST",
+      )(makeArgs({}, { toolName: "computer_use_observe", input: { target } }));
+      expect(result).toMatchObject({
+        success: true,
+        executionTarget: target === "assistant-desktop" ? "sandbox" : "host",
+      });
+      expect(check.mock.calls.at(-1)?.[3]?.executionTarget).toBe(
+        target === "assistant-desktop" ? "sandbox" : "host",
+      );
+    }
+  } finally {
+    unregisterSkillTools(skillId);
+    classify.mockRestore();
+    check.mockRestore();
+  }
+});
+
 function resetContactTables(): void {
   const sqlite = getSqlite();
   sqlite.run("DELETE FROM contact_channels");

package/src/__tests__/skill-script-runner-sandbox.test.ts

@@ -67,6 +67,19 @@ beforeAll(async () => {
     `export async function run() {
   await new Promise(resolve => setTimeout(resolve, 120_000));
   return { content: 'should not reach', isError: false };
+}`,
+    "utf-8",
+  );
+
+  await writeFile(
+    join(tempDir, "plugin-name-echo.ts"),
+    `export async function run() {
+  return {
+    content: JSON.stringify({
+      pluginName: process.env.VELLUM_PLUGIN_NAME ?? null,
+    }),
+    isError: false,
+  };
 }`,
     "utf-8",
   );
@@ -113,6 +126,25 @@ describe("runSkillToolScript sandbox — success", () => {
     expect(parsed.workingDir).toBe("/my/project");
     expect(parsed.conversationId).toBe("sess-42");
   }, 15_000);
+
+  test("sets VELLUM_PLUGIN_NAME for a plugin-owned skill tool", async () => {
+    const result = await runSkillToolScript(
+      tempDir,
+      "plugin-name-echo.ts",
+      {},
+      makeContext(),
+      {
+        target: "sandbox",
+        pluginOwner: "psk-demo",
+      },
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content) as {
+      pluginName: string | null;
+    };
+    expect(parsed.pluginName).toBe("psk-demo");
+  }, 15_000);
 });
 
 // ---------------------------------------------------------------------------

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", () => {

package/src/__tests__/subagent-fork-notifications.test.ts

@@ -22,8 +22,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));
 

package/src/__tests__/subagent-manager-notify.test.ts

@@ -27,8 +27,7 @@ mock.module("../daemon/conversation-registry.js", () => ({
       });
       return { queued: true };
     },
-    persistUserMessage: async () => ({ id: "mock-msg", deduplicated: false }),
-    runAgentLoop: async () => {},
+    kickDrainQueue: async () => {},
   }),
 }));