@vellumai/assistant 0.12.2-staging.1 → 0.12.2-staging.2

package/node_modules/@vellumai/slack-text/src/index.ts

@@ -113,7 +113,7 @@ export async function buildSlackUserLabelMap(
       // that label directly; only queue a lookup when the label is missing,
       // empty, or ID-shaped. Mirrors the channel builder below.
       const [, embeddedLabel] = splitSlackLabel(match[0].slice(1, -1));
-      const sanitizedEmbeddedLabel = sanitizeOptionalLabel(embeddedLabel);
+      const sanitizedEmbeddedLabel = sanitizeEmbeddedSlackLabel(embeddedLabel);
       if (sanitizedEmbeddedLabel && sanitizedEmbeddedLabel !== id) continue;
       if (seen.has(id)) continue;
       seen.add(id);
@@ -151,7 +151,7 @@ export async function buildSlackChannelLabelMap(
     for (const match of text.matchAll(SLACK_CHANNEL_REFERENCE_RE)) {
       const id = match[1];
       const [, embeddedLabel] = splitSlackLabel(match[0].slice(1, -1));
-      const sanitizedEmbeddedLabel = sanitizeOptionalLabel(embeddedLabel);
+      const sanitizedEmbeddedLabel = sanitizeEmbeddedSlackLabel(embeddedLabel);
       if (sanitizedEmbeddedLabel && sanitizedEmbeddedLabel !== id) continue;
       if (!seen.has(id)) {
         seen.add(id);
@@ -192,9 +192,7 @@ function renderUserMention(
   // prefer it over a lookup, mirroring renderChannelReference. The embedded
   // label is Slack-sourced (part of the token), so entities decode before
   // sanitization; the caller-resolved label below is not.
-  const embeddedLabel = sanitizeOptionalLabel(
-    label === undefined ? undefined : decodeSlackHtmlEntities(label),
-  );
+  const embeddedLabel = sanitizeEmbeddedSlackLabel(label);
   if (embeddedLabel && embeddedLabel !== id) {
     return `@${embeddedLabel}`;
   }
@@ -219,9 +217,7 @@ function renderChannelReference(
   );
   // The embedded label is Slack-sourced (part of the token), so entities
   // decode before sanitization; the caller-resolved label below is not.
-  const embeddedLabel = sanitizeOptionalLabel(
-    label === undefined ? undefined : decodeSlackHtmlEntities(label),
-  );
+  const embeddedLabel = sanitizeEmbeddedSlackLabel(label);
   if (embeddedLabel && embeddedLabel !== channelId) {
     return `#${embeddedLabel}`;
   }
@@ -320,6 +316,15 @@ export function sanitizeSlackLabel(
   return sanitized || undefined;
 }
 
+// Slack-sourced labels are decoded before validation in both lookup and render.
+function sanitizeEmbeddedSlackLabel(
+  label: string | undefined,
+): string | undefined {
+  return sanitizeOptionalLabel(
+    label === undefined ? undefined : decodeSlackHtmlEntities(label),
+  );
+}
+
 function sanitizeOptionalLabel(label: string | undefined): string | undefined {
   return sanitizeSlackLabel(label);
 }

package/node_modules/@vellumai/slack-text/src/label-resolution-entities.test.ts

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { describe, test } from "bun:test";
+import {
+  buildSlackChannelLabelMap,
+  buildSlackUserLabelMap,
+  renderSlackTextForModel,
+} from "./index.js";
+
+describe("Slack embedded-label lookup parity", () => {
+  const cases = [
+    { id: "U123", prefix: "@", build: buildSlackUserLabelMap, mapKey: "userLabels" },
+    {
+      id: "C123",
+      prefix: "#",
+      build: buildSlackChannelLabelMap,
+      mapKey: "channelLabels",
+    },
+  ] as const;
+
+  for (const { id, prefix, build, mapKey } of cases) {
+    for (const label of ["<>", `<${id}>`, "< @# >"]) {
+      test(`${prefix} resolves label ${label} after Slack entity decoding`, async () => {
+        const text = `<${prefix}${id}|${label}>`;
+        const requested: string[] = [];
+        const labels = await build([text], async (value) => {
+          requested.push(value);
+          return "Example Name";
+        });
+        assert.deepEqual(requested, [id]);
+        assert.equal(
+          renderSlackTextForModel(text, { [mapKey]: labels }),
+          `${prefix}Example Name`,
+        );
+      });
+    }
+
+    for (const label of ["&lt;Example&gt;", "R&amp;D", "&amp;lt;&amp;gt;"]) {
+      test(`${prefix} keeps usable embedded label ${label} without lookup`, async () => {
+        const requested: string[] = [];
+        const text = `<${prefix}${id}|${label}>`;
+        const labels = await build([text], async (value) => {
+          requested.push(value);
+          return "Wrong Label";
+        });
+        assert.deepEqual(requested, []);
+        assert.deepEqual(labels, {});
+        const expected =
+          label === "&lt;Example&gt;"
+            ? "Example"
+            : label === "R&amp;D"
+              ? "R&D"
+              : "&lt;&gt;";
+        assert.equal(
+          renderSlackTextForModel(text, { [mapKey]: labels }),
+          `${prefix}${expected}`,
+        );
+      });
+    }
+
+    test(`${prefix} deduplicates required lookups across encoded and bare mentions`, async () => {
+      const requested: string[] = [];
+      const labels = await build(
+        [`<${prefix}${id}|&lt;&gt;>`, `<${prefix}${id}>`],
+        async (value) => {
+          requested.push(value);
+          return "Example";
+        },
+      );
+      assert.deepEqual(requested, [id]);
+      assert.deepEqual(labels, { [id]: "Example" });
+    });
+
+    test(`${prefix} does not decode caller-resolved entity text`, async () => {
+      const text = `<${prefix}${id}|&lt;&gt;>`;
+      const labels = await build([text], async () => "&lt;Example&gt;");
+      assert.equal(
+        renderSlackTextForModel(text, { [mapKey]: labels }),
+        `${prefix}&lt;Example&gt;`,
+      );
+    });
+
+    test(`${prefix} preserves unknown fallback after a failed required lookup`, async () => {
+      let attempts = 0;
+      const text = `<${prefix}${id}|&lt;&gt;>`;
+      const labels = await build([text], async () => {
+        attempts++;
+        throw new Error("unavailable");
+      });
+      assert.equal(attempts, 1);
+      assert.deepEqual(labels, {});
+      const expected = prefix === "@" ? "@unknown-user" : "#unknown-channel";
+      assert.equal(renderSlackTextForModel(text, { [mapKey]: labels }), expected);
+    });
+  }
+});

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.12.2
+  version: 0.12.1
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -24481,6 +24481,22 @@ paths:
                             anyOf:
                               - type: string
                               - type: "null"
+                          tenant_host:
+                            anyOf:
+                              - type: object
+                                properties:
+                                  pattern:
+                                    type: string
+                                  label:
+                                    type: string
+                                  placeholder:
+                                    type: string
+                                required:
+                                  - pattern
+                                  - label
+                                  - placeholder
+                                additionalProperties: false
+                              - type: "null"
                           acts_as:
                             type: string
                             enum:
@@ -24497,6 +24513,7 @@ paths:
                           - supports_managed_mode
                           - managed_service_is_paid
                           - feature_flag
+                          - tenant_host
                           - acts_as
                         additionalProperties: false
                       - type: "null"
@@ -25015,6 +25032,22 @@ paths:
                           anyOf:
                             - type: string
                             - type: "null"
+                        tenant_host:
+                          anyOf:
+                            - type: object
+                              properties:
+                                pattern:
+                                  type: string
+                                label:
+                                  type: string
+                                placeholder:
+                                  type: string
+                              required:
+                                - pattern
+                                - label
+                                - placeholder
+                              additionalProperties: false
+                            - type: "null"
                         acts_as:
                           type: string
                           enum:
@@ -25031,6 +25064,7 @@ paths:
                         - supports_managed_mode
                         - managed_service_is_paid
                         - feature_flag
+                        - tenant_host
                         - acts_as
                       additionalProperties: false
                 required:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-staging.1",
+  "version": "0.12.2-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -44,11 +44,11 @@ describe("always-loaded tool count", () => {
     );
     const activeNames = activeTools.map((t) => t.name).sort();
 
-    // `watch_retro_report` survives this baseline for the same reason the
-    // ui_* tools do: a watch retrospective runs clientless, so it can only
-    // report through a tool that survives this baseline. The ui_* tools are
-    // here because background UI surfaces persist and return instead of
-    // awaiting action, so they no longer need a connected client.
+    // `watch_retro_report` survives this baseline because a watch
+    // retrospective runs clientless and can only report through a tool that
+    // stays on this baseline. The ui_* tools stay here because background
+    // surfaces persist and return instead of awaiting action, so a connected
+    // client is not required for the definitions to be present.
     // Host tool definitions stay on the wire for background turns: schemas
     // are cache-stable, and the shared execution gate rejects host tools on
     // explicitly non-interactive turns before any proxy dispatch.

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -119,6 +119,7 @@ import {
   applyRuntimeInjections,
   assembleSlackActiveThreadFocusBlock,
   assembleSlackChronologicalMessages,
+  buildChannelCapabilityBlock,
   buildSubagentStatusBlock,
   getSlackCompactionWatermarkForPrefix,
   getSlackWatermarkAdvanceForRowPrefix,
@@ -586,6 +587,33 @@ describe("injectChannelCapabilityContext", () => {
     expect(text).not.toContain("Do NOT use ui_show, ui_update, or app_create");
   });
 
+  test("guides non-interactive turns to persist UI for a later capable client", () => {
+    const slack: ChannelCapabilities = {
+      channel: "slack",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+    const phone: ChannelCapabilities = {
+      channel: "phone",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    };
+
+    for (const caps of [slack, phone]) {
+      const text = buildChannelCapabilityBlock(caps, undefined, true)!;
+      expect(text).toContain(
+        "ui_show, ui_update, and ui_dismiss persist conversation content",
+      );
+      expect(text).not.toContain("Only use ui_show/ui_update");
+      expect(text).not.toContain("Do NOT use ui_show, ui_update, or app_create");
+      expect(text).not.toContain(
+        "Present information as well-formatted text instead of dynamic UI.",
+      );
+    }
+  });
+
   test("keeps blanket ui_show/ui_update prohibition for other non-dynamic channels", () => {
     const caps: ChannelCapabilities = {
       channel: "phone",

package/src/__tests__/conversation-surfaces-point-at-budget.test.ts

@@ -24,6 +24,7 @@ function proxyDouble() {
       recordAction,
       request,
       reset: () => {},
+      endTask: () => {},
       stepCount: 0,
     },
   };

package/src/__tests__/conversation-surfaces-point-at-capability.test.ts

@@ -30,6 +30,7 @@ function proxyDouble() {
       recordAction: () => {},
       request,
       reset: () => {},
+      endTask: () => {},
       stepCount: 0,
     },
   };

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

@@ -532,6 +532,28 @@ describe("credentials routes", () => {
       );
     });
 
+    test("stores a pasted Claude token without touching leftover refresh material", async () => {
+      secureStore.set("acp:claude_oauth_refresh_token", "stale-refresh");
+      secureStore.set("acp:claude_oauth_expires_at", "111");
+
+      await setRoute!.handler({
+        body: {
+          service: "acp",
+          field: "claude_oauth_token",
+          value: "sk-ant-oat01-pasted-token",
+        },
+      });
+
+      expect(secureStore.get("acp:claude_oauth_token")).toBe(
+        "sk-ant-oat01-pasted-token",
+      );
+      expect(secureStore.get("acp:claude_oauth_refresh_token")).toBe(
+        "stale-refresh",
+      );
+      expect(secureStore.get("acp:claude_oauth_expires_at")).toBe("111");
+    });
+
+
     test("a successful set scrubs the normalized value from transcripts exactly once", async () => {
       /**
        * The pasted plaintext may already sit in recent transcripts, so a
@@ -1301,5 +1323,21 @@ describe("credentials routes", () => {
       // THEN it rejects with a BadRequestError
       await expect(call).rejects.toBeInstanceOf(BadRequestError);
     });
+
+    test("deletes only the requested Claude access-token field", async () => {
+      secureStore.set("acp:claude_oauth_token", "sk-ant-oat01-connected");
+      secureStore.set("acp:claude_oauth_refresh_token", "refresh-leftover");
+      secureStore.set("acp:claude_oauth_expires_at", "111");
+
+      await deleteRoute!.handler({
+        body: { service: "acp", field: "claude_oauth_token" },
+      });
+
+      expect(secureStore.has("acp:claude_oauth_token")).toBe(false);
+      expect(secureStore.get("acp:claude_oauth_refresh_token")).toBe(
+        "refresh-leftover",
+      );
+      expect(secureStore.get("acp:claude_oauth_expires_at")).toBe("111");
+    });
   });
 });

package/src/__tests__/credential-security-invariants.test.ts

@@ -190,7 +190,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "oauth/credential-token-resolver.ts", // centralized access-token key resolution for OAuth and manual-token providers
       "oauth/connection-resolver.ts", // resolve OAuthConnection from oauth-store (access_token lookup)
       "runtime/routes/secret-routes.ts", // HTTP secret management routes (set/delete secrets)
-      "acp/acp-claude-oauth.ts", // Connect Claude OAuth token vault-store helper (stores sk-ant-oat token via setSecureKeyAsync)
+      "acp/acp-claude-oauth.ts", // Connect Claude OAuth token vault-store helper (stores access token plus broker-owned refresh/expiry companions via setSecureKeyAsync)
       "runtime/routes/acp-claude-auth-routes.ts", // Connect Claude Code daemon OAuth flow (stores OAuth token in vault)
       "runtime/routes/migration-routes.ts", // migration import credential restore
       "daemon/conversation-messaging.ts", // credential storage during session messaging

package/src/__tests__/cu-unified-flow.test.ts

@@ -485,8 +485,12 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       // Proxy state is clean after done
       expect(proxy.stepCount).toBe(0);
       expect(proxy.actionHistory).toHaveLength(0);
-      // Only 2 messages sent to client (screenshot + click; done is terminal)
-      expect(sentMessages).toHaveLength(2);
+      // screenshot + click, then done tells the client the task ended so the
+      // helper returns the pointer; done itself never reaches the client
+      expect(sentMessages).toHaveLength(3);
+      expect((sentMessages[2] as Record<string, unknown>).type).toBe(
+        "host_cu_cancel",
+      );
     });
   });
 

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

@@ -1232,6 +1232,38 @@ describe("HostCuProxy", () => {
     });
   });
 
+  describe("endTask", () => {
+    test("tells the desktop the task drove that it is over, once, then resets", async () => {
+      setup();
+
+      const resultPromise = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+      );
+      const requestId = (sentMessages[0] as Record<string, unknown>)
+        .requestId as string;
+      proxy.processObservation(requestId, { axTree: "Button [1]" });
+      await resultPromise;
+
+      proxy.endTask("session-1");
+      const cancels = sentMessages.filter(
+        (m) => (m as Record<string, unknown>).type === "host_cu_cancel",
+      ) as Array<Record<string, unknown>>;
+      expect(cancels).toHaveLength(1);
+      expect(cancels[0].conversationId).toBe("session-1");
+      expect(cancels[0].requestId).not.toBe(requestId);
+
+      proxy.endTask("session-1");
+      expect(
+        sentMessages.filter(
+          (m) => (m as Record<string, unknown>).type === "host_cu_cancel",
+        ),
+      ).toHaveLength(1);
+    });
+  });
+
   describe("late resolve after abort", () => {
     test("resolve is a no-op after abort (entry already deleted)", async () => {
       setup();
@@ -1868,7 +1900,7 @@ describe("HostCuProxy", () => {
     });
   });
 
-  describe("screenshot on request", () => {
+  describe("screenshot policy", () => {
     const TREE = 'Window: "Inbox" (Mail)\n  [1] button "Reply" at (10, 10)';
     const OMITTED = "Screenshot omitted";
 
@@ -1881,15 +1913,20 @@ describe("HostCuProxy", () => {
             "host_cu",
             "host_cu_window_capture",
             "host_cu_annotate",
+            "host_cu_sequence",
           ],
         },
       ];
     }
 
-    /** Dispatch one request and return what was sent, without answering it. */
+    /**
+     * Dispatch one request and return what was sent, without answering it. A
+     * plain observation is the only step whose pixels depend on policy, so it
+     * is the default.
+     */
     function dispatch(
-      input: Record<string, unknown> = { element_id: 1 },
-      toolName = "computer_use_click",
+      input: Record<string, unknown> = {},
+      toolName = "computer_use_observe",
     ) {
       const pending = proxy.request(
         toolName,
@@ -1923,22 +1960,42 @@ describe("HostCuProxy", () => {
       return !Object.hasOwn(sent.input, "includeScreenshot");
     }
 
-    test("the first observed step attaches and the next unscoped step does not", async () => {
+    test("the first observation attaches and the next plain one does not", async () => {
       setup();
       connect();
       const first = await step({ axTree: TREE, screenshot: "img" });
-      expect(first.sent.input).toEqual({ element_id: 1 });
+      expect(first.sent.input).toEqual({});
       expect(first.result.content).not.toContain(OMITTED);
 
       const second = await step({ axTree: TREE });
-      expect(second.sent.input).toEqual({
-        element_id: 1,
-        includeScreenshot: false,
-      });
+      expect(second.sent.input).toEqual({ includeScreenshot: false });
       expect(second.result.content).toContain(OMITTED);
       expect(second.result.isError).toBe(false);
     });
 
+    test("every action attaches after the first look", async () => {
+      setup();
+      connect();
+      await step({ axTree: TREE, screenshot: "img" });
+      for (const [toolName, input] of [
+        ["computer_use_click", { element_id: 1 }],
+        ["computer_use_type_text", { text: "hi" }],
+        ["computer_use_key", { key: "enter" }],
+        ["computer_use_scroll", { direction: "down" }],
+        ["computer_use_wait", { duration: 1 }],
+        ["computer_use_sequence", { actions: [] }],
+      ] as const) {
+        const action = await step(
+          { axTree: TREE, screenshot: "img" },
+          { ...input, include_screenshot: false },
+          toolName,
+        );
+        expect(action.sent.input).toEqual(input);
+        expect(action.result.content).not.toContain(OMITTED);
+        expect(action.result.contentBlocks).toHaveLength(1);
+      }
+    });
+
     test("the first look is per desktop, so a newly targeted one attaches", async () => {
       setup();
       mockClients = [
@@ -1955,8 +2012,8 @@ describe("HostCuProxy", () => {
       ];
       const on = (clientId: string) => {
         const pending = proxy.request(
-          "computer_use_click",
-          { element_id: 1 },
+          "computer_use_observe",
+          {},
           "session-1",
           1,
           undefined,

package/src/__tests__/oauth-commands-routes.test.ts

@@ -1165,6 +1165,33 @@ describe("POST oauth/managed-connect/start", () => {
     expect(result.connect_url).toBe("https://app.vellum.ai/connect/abc");
   });
 
+  test("forwards tenant_host to the platform only when one is supplied", async () => {
+    // Shopify's endpoints live on the merchant's host, which the platform
+    // substitutes into its templates; other providers must not see the key.
+    const bodies: Array<Record<string, unknown>> = [];
+    mockFetchImpl = async (_path, init) => {
+      bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          connect_url: "https://app.vellum.ai/connect/abc",
+        }),
+        text: async () => "",
+      };
+    };
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({
+        body: { provider: "shopify", tenant_host: " my-store.myshopify.com " },
+      }),
+    );
+    await getRoute("POST", "oauth/managed-connect/start").handler(
+      makeArgs({ body: { provider: "google", tenant_host: "   " } }),
+    );
+    expect(bodies[0]?.tenant_host).toBe("my-store.myshopify.com");
+    expect(bodies[1]).not.toHaveProperty("tenant_host");
+  });
+
   test("raises InternalError when platform returns 401", async () => {
     mockFetchImpl = async () => ({
       ok: false,
@@ -1228,6 +1255,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: string;
         account_label: string | null;
         scopes_granted: string[];
+        provider_params: Record<string, string>;
       }>;
     };
     expect(result.ok).toBe(true);
@@ -1236,6 +1264,7 @@ describe("GET oauth/managed-connect/poll", () => {
         id: "conn-1",
         account_label: "alice@example.com",
         scopes_granted: ["email"],
+        provider_params: {},
       },
     ]);
   });
@@ -1248,4 +1277,30 @@ describe("GET oauth/managed-connect/poll", () => {
       ),
     ).rejects.toBeInstanceOf(BadRequestError);
   });
+
+  test("passes through the provider params a connection is scoped by", async () => {
+    // QuickBooks pins the company (realm) the user picked to the connection;
+    // a caller addressing /companyinfo/<realmId> needs it back.
+    mockFetchImpl = async () => ({
+      ok: true,
+      status: 200,
+      json: async () => [
+        {
+          id: "conn-qb",
+          account_label: "Acme Widgets",
+          scopes_granted: ["com.intuit.quickbooks.accounting"],
+          provider_params: { realm_id: "9130357849012345" },
+        },
+      ],
+      text: async () => "",
+    });
+    const result = (await getRoute("GET", "oauth/managed-connect/poll").handler(
+      makeArgs({ queryParams: { provider: "quickbooks" } }),
+    )) as {
+      connections: Array<{ provider_params: Record<string, string> }>;
+    };
+    expect(result.connections[0]?.provider_params).toEqual({
+      realm_id: "9130357849012345",
+    });
+  });
 });

package/src/__tests__/oauth-provider-serializer.test.ts

@@ -291,10 +291,32 @@ describe("serializeProviderSummary", () => {
       supports_managed_mode: true,
       managed_service_is_paid: false,
       feature_flag: null,
+      tenant_host: null,
       acts_as: "user",
     });
   });
 
+  test("exposes the tenant host a per-tenant provider needs at connect", () => {
+    // Shopify's OAuth endpoints live on the merchant's own host, so a client
+    // has to collect it before the managed flow can start. The summary is the
+    // only provider metadata the web client reads, so it carries the ask.
+    const shopify = serializeProviderSummary(makeRow({ provider: "shopify" }))!;
+    expect(shopify.tenant_host).toEqual({
+      pattern: "^[a-z0-9][a-z0-9-]*\\.myshopify\\.com$",
+      label: "Shop domain",
+      placeholder: "your-store.myshopify.com",
+    });
+    expect(
+      new RegExp(shopify.tenant_host!.pattern).test("my-store.myshopify.com"),
+    ).toBe(true);
+    expect(new RegExp(shopify.tenant_host!.pattern).test("evil.com")).toBe(
+      false,
+    );
+    expect(
+      serializeProviderSummary(makeRow({ provider: "github" }))!.tenant_host,
+    ).toBeNull();
+  });
+
   test("names which sense of connected a provider represents", () => {
     // The provider key does not say, and the naming actively misleads:
     // `slack` is the user integration while its bot is `slack_channel`, but

package/src/__tests__/oauth-providers-routes.test.ts

@@ -178,6 +178,7 @@ describe("GET /v1/oauth/providers", () => {
       "supports_managed_mode",
       "managed_service_is_paid",
       "feature_flag",
+      "tenant_host",
       "acts_as",
     ];