@vellumai/assistant 0.8.10 → 0.8.11-staging.1

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

@@ -1,7 +1,7 @@
 /**
- * Tests for the default `history-repair` plugin's `user-prompt-submit` hook.
+ * Tests for the default `history-repair` plugin's hooks.
  *
- * Covers:
+ * `user-prompt-submit`:
  * - The hook normalizes `latestMessages` exactly as `repairHistory` would for
  *   the three documented repair classes (orphan tool_result, missing
  *   tool_result, consecutive same-role messages) and is a no-op for a
@@ -11,6 +11,20 @@
  * - Chain ordering: because defaults register first, the default repair hook
  *   runs ahead of a later-registered user hook, which therefore observes an
  *   already-normalized history.
+ *
+ * `post-model-call` (error-recovery):
+ * - On a provider rejection carrying a repairable ordering error, the hook
+ *   deep-repairs the messages, marks the per-conversation bound, and asks the
+ *   loop to continue.
+ * - Bounded to one pass per turn via that bound: a second consecutive ordering
+ *   rejection is left to surface (the bound is cleared by the `stop` hook, not
+ *   here).
+ * - Ignores non-ordering errors, tool-bearing turns, and finalized (non-error)
+ *   replies — none of which it ever touches the bound for.
+ *
+ * `stop` (terminal cleanup):
+ * - Clears the repair bound unconditionally on the definitive terminal stop, so
+ *   the next turn always repairs afresh no matter how the turn ended.
  */
 
 import { beforeEach, describe, expect, test } from "bun:test";
@@ -18,10 +32,22 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import { HOOKS } from "../plugin-api/constants.js";
 import type {
   PluginLogger,
+  PostModelCallContext,
+  StopContext,
   UserPromptSubmitContext,
 } from "../plugin-api/types.js";
+import postModelCall from "../plugins/defaults/history-repair/hooks/post-model-call.js";
+import stop from "../plugins/defaults/history-repair/hooks/stop.js";
 import userPromptSubmit from "../plugins/defaults/history-repair/hooks/user-prompt-submit.js";
-import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import {
+  isOrderingRepairAttempted,
+  markOrderingRepairAttempted,
+  resetRepairStateStoreForTests,
+} from "../plugins/defaults/history-repair/repair-state-store.js";
+import {
+  deepRepairHistory,
+  repairHistory,
+} from "../plugins/defaults/history-repair/terminal.js";
 import { defaultHistoryRepairPlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
@@ -30,6 +56,10 @@ import {
 } from "../plugins/registry.js";
 import type { Message } from "../providers/types.js";
 
+/** Provider rejection text matched by `isRepairableOrderingError`. */
+const ORDERING_ERROR_MESSAGE =
+  "messages: tool_use ids must have a corresponding tool_result";
+
 const noopLogger: PluginLogger = {
   info: () => {},
   warn: () => {},
@@ -42,6 +72,8 @@ function makeCtx(messages: Message[]): UserPromptSubmitContext {
     conversationId: "conv-test",
     userMessageId: "msg-test",
     requestId: "req-test",
+    modelProfileKey: null,
+    isNonInteractive: false,
     prompt: "",
     originalMessages: messages,
     latestMessages: messages,
@@ -162,3 +194,196 @@ describe("history-repair user-prompt-submit hook — via runHook", () => {
     expect(observed as Message[] | null).toEqual(expected.messages);
   });
 });
+
+// ─── post-model-call hook (error-recovery) ───────────────────────────────────
+
+/** An ordering-violating history: a leading assistant turn deep-repair strips. */
+function orderingViolatingHistory(): Message[] {
+  return [
+    { role: "assistant", content: [{ type: "text", text: "orphaned" }] },
+    { role: "user", content: [{ type: "text", text: "Hello" }] },
+  ];
+}
+
+function makePostModelCallCtx(
+  overrides: Partial<PostModelCallContext> = {},
+): PostModelCallContext {
+  return {
+    conversationId: "conv-pmc",
+    callSite: "mainAgent",
+    content: [],
+    messages: [],
+    stopReason: null,
+    decision: "stop",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+describe("history-repair post-model-call hook — direct", () => {
+  beforeEach(() => {
+    resetRepairStateStoreForTests();
+  });
+
+  test("repairable ordering error → deep-repairs and continues", async () => {
+    // GIVEN a provider rejection carrying a repairable ordering error over a
+    // history with a leading assistant turn.
+    const messages = orderingViolatingHistory();
+    const expected = deepRepairHistory(messages).messages;
+    const ctx = makePostModelCallCtx({
+      messages,
+      error: new Error(ORDERING_ERROR_MESSAGE),
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it rewrites the messages to the deep-repaired history and asks the
+    // loop to retry.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages).toEqual(expected);
+    expect(isOrderingRepairAttempted(ctx.conversationId)).toBe(true);
+  });
+
+  test("second consecutive ordering rejection is left to surface", async () => {
+    // GIVEN a turn whose first ordering rejection already triggered a repair.
+    const conversationId = "conv-bounded";
+    markOrderingRepairAttempted(conversationId);
+    const messages = orderingViolatingHistory();
+    const ctx = makePostModelCallCtx({
+      conversationId,
+      messages,
+      error: new Error(ORDERING_ERROR_MESSAGE),
+    });
+
+    // WHEN a second ordering rejection reaches the hook.
+    await postModelCall(ctx);
+
+    // THEN it does not repair again — the error surfaces.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual(messages);
+
+    // AND the bound stays marked — the hook never clears it; the `stop` hook
+    // clears it at the turn boundary.
+    expect(isOrderingRepairAttempted(conversationId)).toBe(true);
+  });
+
+  test("a non-ordering error while continuing is a no-op", async () => {
+    // GIVEN this turn already repaired an ordering rejection (bound marked),
+    // then an earlier hook recovered a different error and set the decision to
+    // continue.
+    const conversationId = "conv-cross-hook";
+    markOrderingRepairAttempted(conversationId);
+    const ctx = makePostModelCallCtx({
+      conversationId,
+      decision: "continue",
+      error: new Error("image dimensions exceed max allowed size"),
+    });
+
+    // WHEN the history-repair hook runs after that earlier hook.
+    await postModelCall(ctx);
+
+    // THEN it leaves the in-flight continue and the bound alone — it only acts
+    // on a repairable ordering rejection.
+    expect(ctx.decision).toBe("continue");
+    expect(isOrderingRepairAttempted(conversationId)).toBe(true);
+  });
+
+  test("a mid-turn tool-bearing turn is a no-op", async () => {
+    // GIVEN this turn already repaired an ordering rejection (bound marked),
+    // then the model returned a tool-bearing turn the loop continues on its
+    // own.
+    const conversationId = "conv-tool-turn";
+    markOrderingRepairAttempted(conversationId);
+    const ctx = makePostModelCallCtx({
+      conversationId,
+      content: [{ type: "tool_use", id: "tu_1", name: "bash", input: {} }],
+    });
+
+    // WHEN the hook runs over the tool-bearing turn.
+    await postModelCall(ctx);
+
+    // THEN it leaves the decision and the bound alone — there is no provider
+    // rejection to act on.
+    expect(ctx.decision).toBe("stop");
+    expect(isOrderingRepairAttempted(conversationId)).toBe(true);
+  });
+
+  test("non-ordering error is left untouched", async () => {
+    // GIVEN a provider rejection that is not an ordering violation.
+    const messages = orderingViolatingHistory();
+    const ctx = makePostModelCallCtx({
+      messages,
+      error: new Error("rate limit exceeded"),
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it defers — the decision and history are unchanged.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual(messages);
+  });
+
+  test("finalized (non-error) reply is ignored", async () => {
+    // GIVEN a finalized reply — the model returned content, no error.
+    const messages = orderingViolatingHistory();
+    const ctx = makePostModelCallCtx({
+      messages,
+      content: [{ type: "text", text: "done" }],
+      stopReason: "end_turn",
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the model response is left untouched — repair only applies to
+    // ordering rejections.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual(messages);
+  });
+});
+
+// ─── stop hook (terminal cleanup) ────────────────────────────────────────────
+
+function makeStopCtx(overrides: Partial<StopContext> = {}): StopContext {
+  return {
+    conversationId: "conv-stop",
+    messages: [],
+    exitReason: "no_tool_calls",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+describe("history-repair stop hook — direct", () => {
+  beforeEach(() => {
+    resetRepairStateStoreForTests();
+  });
+
+  test("a terminal stop clears the repair bound", async () => {
+    // GIVEN a turn marked a repair-retry.
+    const conversationId = "conv-backstop";
+    markOrderingRepairAttempted(conversationId);
+
+    // WHEN the terminal stop hook runs.
+    await stop(makeStopCtx({ conversationId }));
+
+    // THEN the bound is cleared so the next turn repairs afresh.
+    expect(isOrderingRepairAttempted(conversationId)).toBe(false);
+  });
+
+  test("clears the bound regardless of how the turn ended", async () => {
+    // GIVEN a turn marked a repair-retry that ends on an abort rather than a
+    // finalized reply.
+    const conversationId = "conv-abort";
+    markOrderingRepairAttempted(conversationId);
+
+    // WHEN the terminal stop hook runs for that exit.
+    await stop(makeStopCtx({ conversationId, exitReason: "aborted_pre_call" }));
+
+    // THEN the bound is still cleared — `stop` is the definitive terminal, so
+    // the next turn always repairs afresh.
+    expect(isOrderingRepairAttempted(conversationId)).toBe(false);
+  });
+});

package/src/__tests__/host-app-control-proxy.test.ts

@@ -372,6 +372,49 @@ describe("HostAppControlProxy", () => {
       proxy.dispose();
     });
 
+    test("non-start tool with mismatched target client is rejected", async () => {
+      mockActorMap.set("client-A", "user-1");
+      mockActorMap.set("client-B", "user-1");
+      const proxy = new HostAppControlProxy("conv-1");
+      const startCtrl = new AbortController();
+
+      const pStart = proxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-1",
+        startCtrl.signal,
+        "user-1",
+        "client-A",
+      );
+      proxy.resolve(
+        (sentMessages[0] as Record<string, unknown>).requestId as string,
+        payload({ pngBase64: PNG_A }),
+      );
+      await pStart;
+      sentMessages.length = 0;
+
+      const result = await proxy.request(
+        "app_control_type",
+        {
+          tool: "type",
+          app: "com.example.editor",
+          text: "hello",
+        },
+        "conv-1",
+        new AbortController().signal,
+        "user-1",
+        "client-B",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("client-A");
+      expect(result.content).toContain("client-B");
+      expect(result.content).toContain("app_control_start");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
     test("non-start tool with case-different but otherwise matching app is allowed", async () => {
       const proxy = new HostAppControlProxy("conv-1");
       const startCtrl = new AbortController();
@@ -1297,6 +1340,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(
@@ -1332,6 +1376,7 @@ describe("HostAppControlProxy", () => {
       _setActiveAppControlSession({
         conversationId: "conv-1",
         app: "com.example.app",
+        targetClientId: "client-A",
       });
 
       const resultPromise = proxy.request(

package/src/__tests__/host-browser-proxy.test.ts

@@ -44,6 +44,8 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
       mockClients.find((c) => c.capabilities.includes(cap)),
     listClientsByCapability: (cap: string) =>
       mockClients.filter((c) => c.capabilities.includes(cap)),
+    listClientsByInterface: (interfaceId: string) =>
+      mockClients.filter((c) => c.interfaceId === interfaceId),
     getActorPrincipalIdForClient: (clientId: string) =>
       mockClients.find((c) => c.clientId === clientId)?.actorPrincipalId,
   },
@@ -278,6 +280,53 @@ describe("HostBrowserProxy", () => {
     });
   });
 
+  describe("actor-scoped availability", () => {
+    const EXT_A: MockClient = {
+      clientId: "ext-a",
+      interfaceId: "chrome-extension",
+      actorPrincipalId: "actor-a",
+      capabilities: ["host_browser"],
+    };
+    const BRIDGE_B: MockClient = {
+      clientId: "bridge-b",
+      interfaceId: "macos",
+      actorPrincipalId: "actor-b",
+      capabilities: ["host_browser"],
+    };
+
+    test("isAvailable(actor) only counts that actor's clients", () => {
+      mockClients = [EXT_A, BRIDGE_B];
+      expect(proxy.isAvailable("actor-a")).toBe(true);
+      expect(proxy.isAvailable("actor-b")).toBe(true);
+      expect(proxy.isAvailable("actor-c")).toBe(false);
+      // Legacy no-actor form still counts any client.
+      expect(proxy.isAvailable()).toBe(true);
+    });
+
+    test("hasExtensionClient(actor) ignores other actors' extensions", () => {
+      mockClients = [EXT_A, BRIDGE_B];
+      expect(proxy.hasExtensionClient("actor-a")).toBe(true);
+      // actor-b has only the bridge — actor-a's extension must not count.
+      expect(proxy.hasExtensionClient("actor-b")).toBe(false);
+      expect(proxy.hasExtensionClient()).toBe(true);
+    });
+
+    test("hasExtensionClient(actor) is false for a client without an actor binding", () => {
+      // Strict matching mirrors resolveTargetClient: a legacy extension
+      // connection without an actor is not dispatchable for an
+      // actor-authenticated caller, so it must not count as available.
+      mockClients = [
+        {
+          clientId: "legacy-ext",
+          interfaceId: "chrome-extension",
+          capabilities: ["host_browser"],
+        },
+      ];
+      expect(proxy.hasExtensionClient("actor-a")).toBe(false);
+      expect(proxy.hasExtensionClient()).toBe(true);
+    });
+  });
+
   describe("dispose", () => {
     test("rejects all pending requests and emits cancels", async () => {
       const p1 = proxy.request(
@@ -493,11 +542,12 @@ describe("HostBrowserProxy", () => {
       expect(getPublishedMessages()).toHaveLength(0);
     });
 
-    test("picks the most-recently-active same-actor client among multiple transports", async () => {
+    test("prefers the chrome-extension client over a more-recently-active macOS bridge", async () => {
       // Mock `listClientsByCapability` returns mockClients in array
       // order, which mirrors production's `lastActiveAt`-desc ordering.
-      // The first same-actor entry wins regardless of transport; LLMs
-      // pin a specific transport via `target_client_id`.
+      // The macOS bridge is listed first (most recent heartbeat), but
+      // chrome-extension clients are deterministically preferred for
+      // auto-resolution; LLMs pin the bridge via `target_client_id`.
       mockClients = [
         {
           clientId: "macos-client",
@@ -525,7 +575,7 @@ describe("HostBrowserProxy", () => {
       const requestId = sent.requestId as string;
 
       const pending = pendingInteractions.get(requestId);
-      expect(pending?.targetClientId).toBe("macos-client");
+      expect(pending?.targetClientId).toBe("ext-client");
 
       resolveResult(requestId, { content: "ok", isError: false });
       await resultPromise;
@@ -739,7 +789,7 @@ describe("HostBrowserProxy", () => {
       expect(getPublishedMessages()).toHaveLength(0);
     });
 
-    test("no targetClientId auto-resolves to the most-recently-active same-actor client", async () => {
+    test("no targetClientId auto-resolves with extension preferred over the bridge", async () => {
       mockClients = [
         {
           clientId: "macos-client",
@@ -755,9 +805,9 @@ describe("HostBrowserProxy", () => {
         },
       ];
 
-      // No targetClientId — falls through to the first same-actor
-      // entry by lastActiveAt-desc. Mock array order is the proxy's
-      // input contract.
+      // No targetClientId — auto-resolution partitions chrome-extension
+      // clients ahead of other transports, then picks the first
+      // same-actor entry (lastActiveAt-desc within each group).
       const resultPromise = proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
         "session-1",
@@ -769,10 +819,205 @@ describe("HostBrowserProxy", () => {
       const requestId = (getPublishedMessages()[0] as Record<string, unknown>)
         .requestId as string;
       const pending = pendingInteractions.get(requestId);
-      expect(pending?.targetClientId).toBe("macos-client");
+      expect(pending?.targetClientId).toBe("ext-client");
 
       resolveResult(requestId, { content: "ok", isError: false });
       await resultPromise;
     });
   });
+
+  // ---------------------------------------------------------------------------
+  // Method-aware routing
+  //
+  // `Vellum.*` pseudo-methods are implemented only by the Chrome
+  // extension dispatcher; the macOS bridge speaks raw CDP against
+  // localhost:9222 and fails on all of them. Auto-resolution therefore
+  // restricts pseudo-methods to chrome-extension clients and prefers
+  // the extension over the bridge for raw CDP, instead of racing on
+  // heartbeat-driven lastActiveAt ordering.
+  // ---------------------------------------------------------------------------
+
+  describe("method-aware routing", () => {
+    const MACOS_CLIENT: MockClient = {
+      clientId: "macos-client",
+      interfaceId: "macos",
+      actorPrincipalId: "user-1",
+      capabilities: ["host_browser"],
+    };
+    const EXT_CLIENT: MockClient = {
+      clientId: "ext-client",
+      interfaceId: "chrome-extension",
+      actorPrincipalId: "user-1",
+      capabilities: ["host_browser"],
+    };
+
+    function expectExtensionRequired(result: {
+      content: string;
+      isError: boolean;
+    }): void {
+      expect(result.isError).toBe(true);
+      const parsed = JSON.parse(result.content) as {
+        code: string;
+        message: string;
+      };
+      expect(parsed.code).toBe("extension_required");
+      expect(parsed.message).toContain("Chrome extension");
+    }
+
+    test("pseudo-method routes to the extension even when the bridge is more recently active", async () => {
+      mockClients = [MACOS_CLIENT, EXT_CLIENT];
+
+      const resultPromise = proxy.request(
+        { cdpMethod: "Vellum.listTabs", cdpParams: {} },
+        "session-1",
+        undefined,
+        "user-1",
+      );
+
+      expect(getPublishedMessages()).toHaveLength(1);
+      const requestId = (getPublishedMessages()[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(pendingInteractions.get(requestId)?.targetClientId).toBe(
+        "ext-client",
+      );
+
+      resolveResult(requestId, { content: '{"tabs":[]}', isError: false });
+      await resultPromise;
+    });
+
+    test("pseudo-method with only the macOS bridge connected resolves extension_required without broadcasting", async () => {
+      mockClients = [MACOS_CLIENT];
+
+      const result = await proxy.request(
+        { cdpMethod: "Vellum.selectTab", cdpParams: { tabId: 42 } },
+        "session-1",
+        undefined,
+        "user-1",
+      );
+
+      expectExtensionRequired(result);
+      expect(getPublishedMessages()).toHaveLength(0);
+    });
+
+    test("pseudo-method with no clients resolves extension_required instead of the legacy rejection", async () => {
+      mockClients = [];
+
+      const result = await proxy.request(
+        { cdpMethod: "Vellum.createTab", cdpParams: {} },
+        "session-1",
+      );
+
+      expectExtensionRequired(result);
+      expect(getPublishedMessages()).toHaveLength(0);
+    });
+
+    test("explicit targetClientId at the macOS bridge + pseudo-method resolves extension_required naming the interface", async () => {
+      mockClients = [MACOS_CLIENT, EXT_CLIENT];
+
+      const result = await proxy.request(
+        { cdpMethod: "Vellum.closeTab", cdpParams: { tabId: 7 } },
+        "session-1",
+        undefined,
+        "user-1",
+        "macos-client",
+      );
+
+      expectExtensionRequired(result);
+      const parsed = JSON.parse(result.content) as { message: string };
+      expect(parsed.message).toContain('"macos"');
+      expect(getPublishedMessages()).toHaveLength(0);
+    });
+
+    test("explicit targetClientId at the extension + pseudo-method dispatches normally", async () => {
+      mockClients = [MACOS_CLIENT, EXT_CLIENT];
+
+      const resultPromise = proxy.request(
+        { cdpMethod: "Vellum.closeTab", cdpParams: { tabId: 7 } },
+        "session-1",
+        undefined,
+        "user-1",
+        "ext-client",
+      );
+
+      expect(getPublishedMessages()).toHaveLength(1);
+      const requestId = (getPublishedMessages()[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(pendingInteractions.get(requestId)?.targetClientId).toBe(
+        "ext-client",
+      );
+
+      resolveResult(requestId, {
+        content: '{"closed":true,"tabId":7}',
+        isError: false,
+      });
+      await resultPromise;
+    });
+
+    test("same-actor gate wins over the pseudo-method check for cross-actor explicit targets", async () => {
+      mockClients = [
+        {
+          clientId: "other-user-ext",
+          interfaceId: "chrome-extension",
+          actorPrincipalId: "user-2",
+          capabilities: ["host_browser"],
+        },
+      ];
+
+      const result = await proxy.request(
+        { cdpMethod: "Vellum.listTabs", cdpParams: {} },
+        "session-1",
+        undefined,
+        "user-1",
+        "other-user-ext",
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("Submitting actor does not match");
+      expect(result.content).not.toContain("extension_required");
+      expect(getPublishedMessages()).toHaveLength(0);
+    });
+
+    test("pseudo-method where the only extension belongs to another actor resolves extension_required", async () => {
+      mockClients = [
+        {
+          clientId: "other-user-ext",
+          interfaceId: "chrome-extension",
+          actorPrincipalId: "user-2",
+          capabilities: ["host_browser"],
+        },
+        MACOS_CLIENT,
+      ];
+
+      const result = await proxy.request(
+        { cdpMethod: "Vellum.listTabs", cdpParams: {} },
+        "session-1",
+        undefined,
+        "user-1",
+      );
+
+      expectExtensionRequired(result);
+      expect(getPublishedMessages()).toHaveLength(0);
+    });
+
+    test("raw CDP with only the bridge connected still routes to the bridge", async () => {
+      mockClients = [MACOS_CLIENT];
+
+      const resultPromise = proxy.request(
+        { cdpMethod: "Page.captureScreenshot", cdpParams: {} },
+        "session-1",
+        undefined,
+        "user-1",
+      );
+
+      expect(getPublishedMessages()).toHaveLength(1);
+      const requestId = (getPublishedMessages()[0] as Record<string, unknown>)
+        .requestId as string;
+      expect(pendingInteractions.get(requestId)?.targetClientId).toBe(
+        "macos-client",
+      );
+
+      resolveResult(requestId, { content: '{"data":"..."}', isError: false });
+      await resultPromise;
+    });
+  });
 });

package/src/__tests__/identity-routes.test.ts

@@ -237,6 +237,7 @@ describe("identity routes — health endpoint", () => {
       expect(body.memory).toBeDefined();
       expect(body.cpu).toBeDefined();
       expect(body.migrations).toBeDefined();
+      expect(body.capabilities).toEqual({ memoryOptOut: true });
 
       // Profiler should either be absent or show enabled: false
       if ("profiler" in body) {