@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/notifications/schedule-result-producer.ts

@@ -32,7 +32,6 @@ import { getAttentionStateByConversationIds } from "../persistence/conversation-
 import {
   getAssistantMessageIdsInTurn,
   getMessageById,
-  getMessagesAfter,
   type MessageRow,
 } from "../persistence/conversation-crud.js";
 import { stringifyMessageContent } from "../persistence/message-content.js";
@@ -40,6 +39,7 @@ import {
   isPrivateAssistantText,
   projectPersistedAssistantContent,
 } from "../persistence/user-facing-content.js";
+import type { ContentBlock } from "../providers/types.js";
 import { emitNotificationSignal } from "./emit-signal.js";
 import { hasNotifiedSourceContextSince } from "./events-store.js";
 import {
@@ -79,72 +79,28 @@ export interface ScheduleResultNotificationParams {
 }
 
 /**
- * Whether the run delivered its result through the messaging tool, and the
- * call succeeded.
+ * Whether a tool call in the run's turn delivered the result somewhere the
+ * user will see it, outside the notification pipeline.
  *
- * The messaging tool is the route the schedule skill prescribes for rich
- * content, and it writes no `notification_events` row, so the pipeline probe
- * cannot see it. Without this check a well-authored Slack digest would post
+ * The schedule skill prescribes two such routes for rich content — the
+ * messaging tool for email, and the Slack Web API's `chat.postMessage` through
+ * bash — and neither writes a `notification_events` row, so the pipeline probe
+ * cannot see them. Without this check a well-authored Slack digest would post
  * its summary and then get a second notification whose body is "Posted the
- * digest to #general."
- *
- * Both conditions are load-bearing. The route has to be recognized, because
- * this is a known-routes list rather than a general "did the run do anything?"
- * heuristic. And the call has to have succeeded: a `tool_use` block records
- * only that the model called the tool, so a send the channel refused leaves
- * the same block as one that landed, and suppressing on it costs the user both
- * the digest and the run's explanation of the failure. The executor's verdict
- * is on the `tool_result` the call produced, so success is read from there,
- * and a call with no result counts as undelivered. Either condition unmet gets
- * the fallback, which is the safe failure.
- *
- * The result read starts at the run's first row, so it covers the results
- * interleaved through the turn. Rows from a later turn in a reused
- * conversation can come back too and are harmless, because only this run's
- * own call ids are matched.
- *
- * A Slack Web API post through bash is deliberately not a route, because its
- * success proves nothing about the post. Slack refuses a call with HTTP 200
- * and `ok: false` in the body, and the authenticated-request command fails
- * only on a non-2xx status, so a post Slack refused still leaves a successful
- * tool result. A run that posts that way gets the fallback too: at worst a
- * duplicate, never a silence.
+ * digest to #general." This is a recognized-routes list, not a general "did
+ * the run do anything?" heuristic: a route that is not here gets the fallback,
+ * which is the safe failure.
  */
-function deliveredThroughMessagingTool(
-  conversationId: string,
-  runRows: readonly MessageRow[],
-): boolean {
-  const callIds = new Set<string>();
-  for (const row of runRows) {
-    for (const block of row.content) {
-      if (block.type === "tool_use" && block.name === "messaging_send") {
-        callIds.add(block.id);
-      }
-    }
-  }
-  if (callIds.size === 0) {
+function isDirectDelivery(block: ContentBlock): boolean {
+  if (block.type !== "tool_use") {
     return false;
   }
-  const [firstRunRow] = runRows;
-  for (const row of getMessagesAfter(conversationId, {
-    id: firstRunRow.id,
-    createdAt: firstRunRow.createdAt,
-  })) {
-    if (row.role !== "user") {
-      continue;
-    }
-    for (const block of row.content) {
-      // guard:allow-tool-result-only: the local executor's verdict on a
-      // delivery it ran. A server-side `web_search_tool_result` carries no
-      // `is_error` and never delivers anything.
-      if (
-        block.type === "tool_result" &&
-        block.is_error !== true &&
-        callIds.has(block.tool_use_id)
-      ) {
-        return true;
-      }
-    }
+  if (block.name === "messaging_send") {
+    return true;
+  }
+  if (block.name === "bash") {
+    const command = (block.input as { command?: unknown } | undefined)?.command;
+    return typeof command === "string" && command.includes("chat.postMessage");
   }
   return false;
 }
@@ -281,11 +237,11 @@ export async function emitScheduleResultNotification(
       return;
     }
 
-    // The run delivered around the pipeline through the messaging tool, and
-    // the call succeeded. The user has the result; a notification reading
-    // "posted it" on top would be the duplicate.
+    // The run delivered around the pipeline — an email through the messaging
+    // tool, a Slack post through the Web API. The user has the result; a
+    // notification reading "posted it" on top would be the duplicate.
     const runRows = collectRunRows(latestRow, conversationId, runStartedAt);
-    if (deliveredThroughMessagingTool(conversationId, runRows)) {
+    if (runRows.some((row) => row.content.some(isDirectDelivery))) {
       return;
     }
 

package/src/oauth/__tests__/seed-providers-managed.test.ts

@@ -127,60 +127,6 @@ describe("PROVIDER_SEED_DATA managed mode wiring", () => {
     expect(figma.featureFlag).toBe("figma-oauth");
   });
 
-  test("shopify keeps its per-tenant URL templates", () => {
-    // Shopify has no global OAuth host: every endpoint lives on the
-    // merchant's own domain. Hardcoding any host here would send every
-    // merchant's authorization to the wrong store, so the {tenant_host}
-    // placeholder the platform substitutes must survive.
-    const shopify = PROVIDER_SEED_DATA.shopify;
-    expect(shopify).toBeDefined();
-    for (const url of [
-      shopify.authorizeUrl,
-      shopify.tokenExchangeUrl,
-      shopify.refreshUrl,
-      shopify.baseUrl,
-      shopify.identityUrl,
-    ]) {
-      expect(url).toContain("{tenant_host}");
-    }
-  });
-
-  test("shopify requests comma-separated scopes", () => {
-    // Shopify parses `scope` as a comma-separated list; the OAuth2 default
-    // space separator is read as one malformed scope and the whole
-    // authorization request is rejected.
-    expect(PROVIDER_SEED_DATA.shopify.scopeSeparator).toBe(",");
-  });
-
-  test("shopify does not request approval-gated scopes", () => {
-    // Shopify rejects the entire authorization request when the app cannot
-    // grant a requested scope -- the same failure that broke monday and
-    // Figma. These scopes all require Shopify's prior approval.
-    const gated = [
-      "read_all_orders",
-      "read_customer_payment_methods",
-      "read_own_subscription_contracts",
-      "write_own_subscription_contracts",
-      "read_shopify_payments_dispute_evidences",
-      "write_shopify_payments_dispute_evidences",
-    ];
-    for (const scope of gated) {
-      expect(PROVIDER_SEED_DATA.shopify.defaultScopes).not.toContain(scope);
-    }
-  });
-
-  test("shopify injects the Admin API's own auth header", () => {
-    // The Admin API reads X-Shopify-Access-Token and ignores an
-    // Authorization: Bearer header entirely, so a Bearer template here would
-    // make every proxied request unauthenticated.
-    const templates = PROVIDER_SEED_DATA.shopify.injectionTemplates;
-    expect(templates).toBeDefined();
-    const [template] = templates ?? [];
-    expect(template?.headerName).toBe("X-Shopify-Access-Token");
-    expect(template?.valuePrefix).toBe("");
-    expect(template?.hostPattern).toBe("*.myshopify.com");
-  });
-
   test("every managedServiceConfigKey resolves to a ServicesSchema key", () => {
     // Cross-repo invariant: a provider with managedServiceConfigKey but no
     // matching ServicesSchema entry silently falls back to BYO mode in

package/src/oauth/byo-connection.test.ts

@@ -708,51 +708,6 @@ describe("BYOOAuthConnection", () => {
       expect(headers.get("Authorization")).toBe("Bearer test-access-token");
     });
 
-    test("sends the token in the provider's own header when one is configured", async () => {
-      // Shopify's Admin API reads X-Shopify-Access-Token and ignores
-      // Authorization, so a Bearer header reaches the shop unauthenticated.
-      await setupCredential("google");
-      const conn = new BYOOAuthConnection({
-        id: "conn-google",
-        provider: "google",
-        baseUrl: "https://example-store.myshopify.com",
-        accountInfo: null,
-        tokenHeader: { name: "X-Shopify-Access-Token", valuePrefix: "" },
-      });
-
-      await conn.request({
-        method: "GET",
-        path: "/admin/api/2026-07/shop.json",
-        // A caller-supplied Authorization must not ride along.
-        headers: { Authorization: "Bearer caller-supplied" },
-      });
-
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toBe(
-        "https://example-store.myshopify.com/admin/api/2026-07/shop.json",
-      );
-      const headers = (init as RequestInit).headers as Headers;
-      expect(headers.get("X-Shopify-Access-Token")).toBe("test-access-token");
-      expect(headers.has("Authorization")).toBe(false);
-    });
-
-    test("keeps the value prefix from the token header template", async () => {
-      await setupCredential("google");
-      const conn = new BYOOAuthConnection({
-        id: "conn-google",
-        provider: "google",
-        baseUrl: "https://discord.com/api",
-        accountInfo: null,
-        tokenHeader: { name: "Authorization", valuePrefix: "Bot " },
-      });
-
-      await conn.request({ method: "GET", path: "/users/@me" });
-
-      const [, init] = mockFetch.mock.calls[0];
-      const headers = (init as RequestInit).headers as Headers;
-      expect(headers.get("Authorization")).toBe("Bot test-access-token");
-    });
-
     test("uses Telegram Bot API token URL format without Bearer auth", async () => {
       await setupTelegramCredential();
       const conn = createConnection("telegram");

package/src/oauth/byo-connection.ts

@@ -21,29 +21,11 @@ const log = getLogger("byo-oauth-connection");
 /** Default per-request timeout to prevent hung requests from blocking indefinitely. */
 const REQUEST_TIMEOUT_MS = 30_000;
 
-/**
- * How the access token is attached to an outbound request. Almost every
- * provider reads `Authorization: Bearer <token>`; a few use their own header
- * (Shopify's Admin API reads `X-Shopify-Access-Token` and ignores
- * Authorization entirely). Derived from the provider's header-type injection
- * template so the seed is the single source of truth.
- */
-export interface BYOTokenHeader {
-  name: string;
-  /** Text placed before the token, e.g. `"Bearer "`, `"Bot "`, or `""`. */
-  valuePrefix: string;
-}
-
 export interface BYOOAuthConnectionOptions {
   id: string;
   provider: string;
   baseUrl: string;
   accountInfo: string | null;
-  /**
-   * Token header override. When omitted the connection falls back to
-   * `Authorization: Bearer` (or `Bot` for discord_channel).
-   */
-  tokenHeader?: BYOTokenHeader | null;
 }
 
 export class BYOOAuthConnection implements OAuthConnection {
@@ -52,14 +34,12 @@ export class BYOOAuthConnection implements OAuthConnection {
   readonly accountInfo: string | null;
 
   private readonly baseUrl: string;
-  private readonly tokenHeader: BYOTokenHeader | null;
 
   constructor(opts: BYOOAuthConnectionOptions) {
     this.id = opts.id;
     this.provider = opts.provider;
     this.baseUrl = opts.baseUrl;
     this.accountInfo = opts.accountInfo;
-    this.tokenHeader = opts.tokenHeader ?? null;
   }
 
   async request(req: OAuthConnectionRequest): Promise<OAuthConnectionResponse> {
@@ -71,12 +51,8 @@ export class BYOOAuthConnection implements OAuthConnection {
         // Discord bot tokens authenticate with the `Bot ` scheme, not
         // `Bearer`. Sending Bearer here reaches Discord as an unusable
         // credential and comes back 401, which reads as a revoked token.
-        // Providers with their own token header (Shopify) override the
-        // whole thing via `tokenHeader`.
-        const tokenHeader: BYOTokenHeader = this.tokenHeader ?? {
-          name: "Authorization",
-          valuePrefix: this.provider === "discord_channel" ? "Bot " : "Bearer ",
-        };
+        const authScheme =
+          this.provider === "discord_channel" ? "Bot" : "Bearer";
         const requestPath = isTelegram
           ? buildTelegramBotApiPath(req.path, token)
           : req.path;
@@ -117,22 +93,16 @@ export class BYOOAuthConnection implements OAuthConnection {
           }
         }
         if (!isTelegram) {
-          // The credential always wins over a caller-supplied value, and a
-          // provider that reads its own header must not also receive a
-          // stray Authorization the caller happened to send.
-          if (tokenHeader.name.toLowerCase() !== "authorization") {
-            headers.delete("Authorization");
-          }
-          headers.set(tokenHeader.name, `${tokenHeader.valuePrefix}${token}`);
+          headers.set("Authorization", `${authScheme} ${token}`);
         }
 
         const resp = await fetch(fullUrl, {
           method: req.method,
           headers,
           body: hasBody
-            ? binaryBody !== undefined
-              ? Buffer.from(binaryBody)
-              : (rawBody ?? JSON.stringify(req.body))
+            ? (binaryBody !== undefined
+                ? Buffer.from(binaryBody)
+                : (rawBody ?? JSON.stringify(req.body)))
             : undefined,
           // Following a redirect would replay a POST as a GET against a URL
           // the caller never asked for, and hide the 3xx from them.

package/src/oauth/connection-resolver.test.ts

@@ -75,7 +75,6 @@ import {
   resolveEffectiveBaseUrl,
   resolveOAuthConnection,
   resolveOAuthConnectionWithMeta,
-  resolveTokenHeader,
 } from "./connection-resolver.js";
 import { PlatformOAuthConnection } from "./platform-connection.js";
 
@@ -754,75 +753,3 @@ describe("resolveEffectiveBaseUrl", () => {
     ).toBe("https://gmail.googleapis.com/gmail/v1/users/me");
   });
 });
-
-describe("resolveTokenHeader", () => {
-  const shopify = JSON.stringify([
-    {
-      hostPattern: "*.myshopify.com",
-      injectionType: "header",
-      headerName: "X-Shopify-Access-Token",
-      valuePrefix: "",
-    },
-  ]);
-
-  test("returns null when the provider declares no templates", () => {
-    expect(resolveTokenHeader(undefined, "https://api.example.com")).toBeNull();
-    expect(resolveTokenHeader(null, "https://api.example.com")).toBeNull();
-    expect(resolveTokenHeader("[]", "https://api.example.com")).toBeNull();
-  });
-
-  test("returns null for malformed JSON", () => {
-    expect(
-      resolveTokenHeader("{not json", "https://api.example.com"),
-    ).toBeNull();
-  });
-
-  test("ignores non-header injection templates", () => {
-    const query = JSON.stringify([
-      {
-        hostPattern: "api.example.com",
-        injectionType: "query",
-        headerName: "",
-      },
-    ]);
-    expect(resolveTokenHeader(query, "https://api.example.com")).toBeNull();
-  });
-
-  test("picks the template whose wildcard host pattern matches the base URL", () => {
-    const templates = JSON.stringify([
-      {
-        hostPattern: "api.other.com",
-        injectionType: "header",
-        headerName: "Authorization",
-        valuePrefix: "Bearer ",
-      },
-      ...JSON.parse(shopify),
-    ]);
-    expect(
-      resolveTokenHeader(templates, "https://example-store.myshopify.com"),
-    ).toEqual({ name: "X-Shopify-Access-Token", valuePrefix: "" });
-  });
-
-  test("falls back to the first header template when the host cannot be matched", () => {
-    // A still-templated base URL is not a parseable URL.
-    expect(resolveTokenHeader(shopify, "https://{tenant_host}")).toEqual({
-      name: "X-Shopify-Access-Token",
-      valuePrefix: "",
-    });
-  });
-
-  test("preserves the Bot prefix for discord_channel", () => {
-    const discord = JSON.stringify([
-      {
-        hostPattern: "discord.com",
-        injectionType: "header",
-        headerName: "Authorization",
-        valuePrefix: "Bot ",
-      },
-    ]);
-    expect(resolveTokenHeader(discord, "https://discord.com/api")).toEqual({
-      name: "Authorization",
-      valuePrefix: "Bot ",
-    });
-  });
-});

package/src/oauth/connection-resolver.ts

@@ -6,7 +6,7 @@ import {
 } from "../config/schemas/services.js";
 import { VellumPlatformClient } from "../platform/client.js";
 import { getLogger } from "../util/logger.js";
-import { BYOOAuthConnection, type BYOTokenHeader } from "./byo-connection.js";
+import { BYOOAuthConnection } from "./byo-connection.js";
 import type { OAuthConnection } from "./connection.js";
 import { getConnectionAccessTokenResult } from "./credential-token-resolver.js";
 import { syncManualTokenConnection } from "./manual-token-connection.js";
@@ -215,108 +215,15 @@ export async function resolveOAuthConnectionWithMeta(
     );
   }
 
-  const effectiveBaseUrl = resolveEffectiveBaseUrl(
-    conn.provider,
-    baseUrl,
-    conn.metadata,
-  );
   const connection = new BYOOAuthConnection({
     id: conn.id,
     provider: conn.provider,
-    baseUrl: effectiveBaseUrl,
+    baseUrl: resolveEffectiveBaseUrl(conn.provider, baseUrl, conn.metadata),
     accountInfo: conn.accountInfo,
-    tokenHeader: resolveTokenHeader(
-      providerRow?.injectionTemplates,
-      effectiveBaseUrl,
-    ),
   });
   return { connection, ambiguous, allAccounts };
 }
 
-/**
- * Pick the header a provider expects its access token in from the seed's
- * header-type injection templates.
- *
- * Prefers the template whose `hostPattern` matches the base URL's host
- * (`*.myshopify.com` style globs included), then falls back to the first
- * header template. Returns `null` when the provider declares none, which
- * leaves `BYOOAuthConnection` on its `Authorization: Bearer` default.
- *
- * Shopify is why this exists: its Admin API reads `X-Shopify-Access-Token`
- * and ignores `Authorization`, so a Bearer header reaches the shop as an
- * unauthenticated request and comes back 401.
- */
-export function resolveTokenHeader(
-  rawTemplates: string | null | undefined,
-  baseUrl: string,
-): BYOTokenHeader | null {
-  if (!rawTemplates) {
-    return null;
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(rawTemplates);
-  } catch {
-    return null;
-  }
-  if (!Array.isArray(parsed)) {
-    return null;
-  }
-
-  const headerTemplates = parsed.filter(
-    (
-      t,
-    ): t is {
-      hostPattern?: unknown;
-      headerName: string;
-      valuePrefix?: unknown;
-    } =>
-      typeof t === "object" &&
-      t !== null &&
-      (t as { injectionType?: unknown }).injectionType === "header" &&
-      typeof (t as { headerName?: unknown }).headerName === "string" &&
-      (t as { headerName: string }).headerName.trim() !== "",
-  );
-  if (headerTemplates.length === 0) {
-    return null;
-  }
-
-  let host = "";
-  try {
-    host = new URL(baseUrl).hostname.toLowerCase();
-  } catch {
-    // Templated or malformed base URLs (e.g. a still-unfilled
-    // `https://{tenant_host}`) cannot be matched by host; fall through to
-    // the first header template.
-  }
-  const matching =
-    host === ""
-      ? undefined
-      : headerTemplates.find(
-          (t) =>
-            typeof t.hostPattern === "string" &&
-            hostMatchesPattern(host, t.hostPattern),
-        );
-  const chosen = matching ?? headerTemplates[0];
-  return {
-    name: chosen.headerName.trim(),
-    valuePrefix:
-      typeof chosen.valuePrefix === "string" ? chosen.valuePrefix : "",
-  };
-}
-
-function hostMatchesPattern(host: string, pattern: string): boolean {
-  const p = pattern.trim().toLowerCase();
-  if (p === "") {
-    return false;
-  }
-  if (p.startsWith("*.")) {
-    const suffix = p.slice(1); // ".myshopify.com"
-    return host.endsWith(suffix) && host.length > suffix.length;
-  }
-  return host === p;
-}
-
 /**
  * Resolve the effective API base URL for a connection, preferring per-tenant
  * values stored on the connection's `metadata` over the provider's static