@vellumai/assistant 0.7.0 → 0.7.1

package/node_modules/@vellumai/skill-host-contracts/src/tool-types.ts

@@ -142,6 +142,8 @@ export interface ToolExecutionResult {
   riskLevel?: string;
   /** Human-readable reason for the risk classification. */
   riskReason?: string;
+  /** ID of the trust rule that matched this invocation (if any). */
+  matchedTrustRuleId?: string;
   /** Whether the daemon is running in a containerized (Docker) environment. */
   isContainerized?: boolean;
   /** Scope options ladder for the rule editor (narrowest to broadest). */
@@ -212,6 +214,8 @@ export interface ToolPermissionDeniedEvent extends ToolLifecycleEventBase {
   riskLevel: string;
   /** Classifier-provided reason explaining why the risk level was assigned (bash/host_bash only). */
   riskReason?: string;
+  /** ID of the trust rule that matched this invocation (if any). */
+  matchedTrustRuleId?: string;
   decision: "deny" | "always_deny";
   reason: string;
   durationMs: number;
@@ -220,6 +224,8 @@ export interface ToolPermissionDeniedEvent extends ToolLifecycleEventBase {
 export interface ToolExecutedEvent extends ToolLifecycleEventBase {
   type: "executed";
   riskLevel: string;
+  /** ID of the trust rule that matched this invocation (if any). */
+  matchedTrustRuleId?: string;
   decision: string;
   durationMs: number;
   result: ToolExecutionResult;
@@ -228,6 +234,8 @@ export interface ToolExecutedEvent extends ToolLifecycleEventBase {
 export interface ToolExecutionErrorEvent extends ToolLifecycleEventBase {
   type: "error";
   riskLevel: string;
+  /** ID of the trust rule that matched this invocation (if any). */
+  matchedTrustRuleId?: string;
   decision: string;
   durationMs: number;
   errorMessage: string;
@@ -238,20 +246,12 @@ export interface ToolExecutionErrorEvent extends ToolLifecycleEventBase {
   errorStack?: string;
 }
 
-export interface ToolSecretDetectedEvent extends ToolLifecycleEventBase {
-  type: "secret_detected";
-  matches: Array<{ type: string; redactedValue: string }>;
-  action: "redact" | "warn" | "block" | "prompt";
-  detectedAtMs: number;
-}
-
 export type ToolLifecycleEvent =
   | ToolExecutionStartEvent
   | ToolPermissionPromptEvent
   | ToolPermissionDeniedEvent
   | ToolExecutedEvent
-  | ToolExecutionErrorEvent
-  | ToolSecretDetectedEvent;
+  | ToolExecutionErrorEvent;
 
 export type ToolLifecycleEventHandler = (
   event: ToolLifecycleEvent,
@@ -279,7 +279,7 @@ export interface ToolContext {
   onOutput?: (chunk: string) => void;
   /** Abort signal for cooperative cancellation. Tools should check this periodically. */
   signal?: AbortSignal;
-  /** Optional callback for tool lifecycle events (start/prompt/deny/execute/error/secret_detected). */
+  /** Optional callback for tool lifecycle events (start/prompt/deny/execute/error). */
   onToolLifecycleEvent?: ToolLifecycleEventHandler;
   /** Optional resolver for proxy tools - delegates execution to an external client. */
   proxyToolResolver?: ProxyToolResolver;
@@ -397,8 +397,8 @@ export interface ToolContext {
    */
   transportInterface?: string;
   /**
-   * True when the host browser proxy's sender was overridden by a
-   * registry-routed extension connection (ChromeExtensionRegistry WebSocket).
+   * True when the host browser proxy's sender was overridden by an
+   * extension connection (WebSocket browser-relay).
    * The CDP factory uses this to distinguish between an SSE-backed proxy
    * (macOS, no extension) and an extension-backed proxy: only the latter
    * should suppress desktop-auto cdp-inspect when temporarily unavailable,

package/node_modules/@vellumai/slack-text/bun.lock

@@ -0,0 +1,24 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@vellumai/slack-text",
+      "devDependencies": {
+        "@types/bun": "1.3.10",
+        "typescript": "5.9.3",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
+
+    "@types/node": ["@types/node@25.6.0", "", { "dependencies": { "undici-types": "~7.19.0" } }, "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ=="],
+
+    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.19.2", "", {}, "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="],
+  }
+}

package/node_modules/@vellumai/slack-text/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@vellumai/slack-text",
+  "version": "0.0.1",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test src/"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.10",
+    "typescript": "5.9.3"
+  }
+}

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

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  buildSlackUserLabelMap,
+  extractSlackUserMentionIds,
+  renderSlackTextForModel,
+  stripLeadingSlackMentionFallback,
+  stripLeadingSlackUserMention,
+} from "./index.js";
+
+describe("extractSlackUserMentionIds", () => {
+  test("returns unique user mention IDs in encounter order", () => {
+    expect(
+      extractSlackUserMentionIds("<@U123> hi <@W456> and <@U123> again")
+    ).toEqual(["U123", "W456"]);
+  });
+});
+
+describe("stripLeadingSlackUserMention", () => {
+  test("strips only leading mentions for the exact bot ID", () => {
+    expect(stripLeadingSlackUserMention("<@U111> <@U222> hi", "U111")).toBe(
+      "<@U222> hi"
+    );
+  });
+
+  test("strips repeated leading mentions for the exact bot ID", () => {
+    expect(stripLeadingSlackUserMention(" <@U111> <@U111> hi", "U111")).toBe(
+      "hi"
+    );
+  });
+
+  test("preserves text when the leading mention is a different user", () => {
+    expect(stripLeadingSlackUserMention("<@U222> hi <@U111>", "U111")).toBe(
+      "<@U222> hi <@U111>"
+    );
+  });
+});
+
+describe("stripLeadingSlackMentionFallback", () => {
+  test("strips only the first leading Slack user mention", () => {
+    expect(stripLeadingSlackMentionFallback(" <@U111> <@U222> hi")).toBe(
+      "<@U222> hi"
+    );
+  });
+});
+
+describe("renderSlackTextForModel", () => {
+  test("renders resolved user mentions", () => {
+    expect(
+      renderSlackTextForModel("hello <@U123>", {
+        userLabels: { U123: "Alice" },
+      })
+    ).toBe("hello @Alice");
+  });
+
+  test("renders multiple mentions and never emits unresolved user IDs", () => {
+    const rendered = renderSlackTextForModel("<@U123> <@W456> <@U789>", {
+      userLabels: { U123: "Alice", W456: "Bob" },
+    });
+
+    expect(rendered).toBe("@Alice @Bob @unknown-user");
+    expect(rendered).not.toContain("U789");
+  });
+
+  test("treats ID-shaped resolved user labels as unresolved", () => {
+    expect(
+      renderSlackTextForModel("hello <@U123>", {
+        userLabels: { U123: "U123" },
+      })
+    ).toBe("hello @unknown-user");
+  });
+
+  test("renders channel references with labels and fallbacks", () => {
+    expect(
+      renderSlackTextForModel("<#C123|general> <#C456>", {
+        channelLabels: { C456: "support" },
+      })
+    ).toBe("#general #support");
+
+    expect(renderSlackTextForModel("<#C789>")).toBe("#unknown-channel");
+  });
+
+  test("renders special broadcasts", () => {
+    expect(renderSlackTextForModel("<!here> <!channel> <!everyone>")).toBe(
+      "@here @channel @everyone"
+    );
+  });
+
+  test("renders usergroups with labels and fallback", () => {
+    expect(renderSlackTextForModel("<!subteam^S123|eng> <!subteam^S456>")).toBe(
+      "@eng @usergroup"
+    );
+  });
+
+  test("renders labeled and unlabeled links", () => {
+    expect(
+      renderSlackTextForModel(
+        "<https://example.com|Example> <https://example.org>"
+      )
+    ).toBe("Example (https://example.com) https://example.org");
+  });
+
+  test("sanitizes malicious and empty labels before adding prefixes", () => {
+    expect(
+      renderSlackTextForModel(
+        "<@U123> <#C123> <#C456|#  > <!subteam^S123|@eng>",
+        {
+          userLabels: { U123: " @<system>  prompt " },
+          channelLabels: { C123: "#<ops>" },
+        }
+      )
+    ).toBe("@system prompt #ops #unknown-channel @eng");
+  });
+
+  test("uses sanitized custom fallbacks", () => {
+    expect(
+      renderSlackTextForModel("<@U123> <#C123>", {
+        userFallbackLabel: "@ missing user ",
+        channelFallbackLabel: "# missing channel ",
+      })
+    ).toBe("@missing user #missing channel");
+  });
+});
+
+describe("buildSlackUserLabelMap", () => {
+  test("dedupes mentioned users across text inputs and ignores configured IDs", async () => {
+    const resolved: string[] = [];
+    const labels = await buildSlackUserLabelMap(
+      ["<@U123> hi <@U999>", undefined, "<@U123> and <@W456>"],
+      async (userId) => {
+        resolved.push(userId);
+        return userId === "W456" ? "Bob" : "Alice";
+      },
+      { ignoredUserIds: ["U999"] }
+    );
+
+    expect(resolved).toEqual(["U123", "W456"]);
+    expect(labels).toEqual({ U123: "Alice", W456: "Bob" });
+  });
+
+  test("omits unresolved labels and labels equal to the Slack user ID", async () => {
+    const labels = await buildSlackUserLabelMap(
+      ["<@U123> <@U456> <@U789>"],
+      async (userId) => {
+        if (userId === "U123") return "U123";
+        if (userId === "U456") return "";
+        return "Alice";
+      }
+    );
+
+    expect(labels).toEqual({ U789: "Alice" });
+  });
+});

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

@@ -0,0 +1,235 @@
+export interface RenderSlackTextOptions {
+  userLabels?: Record<string, string>;
+  channelLabels?: Record<string, string>;
+  userFallbackLabel?: string;
+  channelFallbackLabel?: string;
+}
+
+export interface BuildSlackUserLabelMapOptions {
+  ignoredUserIds?: Iterable<string | undefined>;
+}
+
+const SLACK_USER_MENTION_RE = /<@([UW][A-Z0-9]+)>/g;
+const LEADING_SLACK_USER_MENTION_RE = /^\s*<@[UW][A-Z0-9]+>\s*/;
+
+export function extractSlackUserMentionIds(text: string): string[] {
+  const seen = new Set<string>();
+  const ids: string[] = [];
+
+  for (const match of text.matchAll(SLACK_USER_MENTION_RE)) {
+    const id = match[1];
+    if (!seen.has(id)) {
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+
+  return ids;
+}
+
+export function stripLeadingSlackUserMention(
+  text: string,
+  userId: string
+): string {
+  if (!isSlackUserId(userId)) {
+    return text;
+  }
+
+  const mention = `<@${userId}>`;
+  let stripped = text;
+
+  while (true) {
+    const next = stripLeadingExactToken(stripped, mention);
+    if (next === stripped) {
+      return stripped;
+    }
+    stripped = next;
+  }
+}
+
+export function stripLeadingSlackMentionFallback(text: string): string {
+  return text.replace(LEADING_SLACK_USER_MENTION_RE, "");
+}
+
+export function renderSlackTextForModel(
+  text: string,
+  options: RenderSlackTextOptions = {}
+): string {
+  return text.replace(/<([^<>\s][^<>]*)>/g, (token, content: string) => {
+    if (content.startsWith("@")) {
+      return renderUserMention(content, options);
+    }
+
+    if (content.startsWith("#")) {
+      return renderChannelReference(content, options);
+    }
+
+    if (content.startsWith("!")) {
+      return renderSpecialReference(content);
+    }
+
+    if (looksLikeUrl(content)) {
+      return renderLink(content);
+    }
+
+    return token;
+  });
+}
+
+export async function buildSlackUserLabelMap(
+  texts: Iterable<string | undefined>,
+  resolveLabel: (userId: string) => Promise<string | undefined | null>,
+  options: BuildSlackUserLabelMapOptions = {}
+): Promise<Record<string, string>> {
+  const ignored = new Set(
+    [...(options.ignoredUserIds ?? [])].filter(
+      (id): id is string => typeof id === "string" && id.length > 0
+    )
+  );
+  const ids: string[] = [];
+  const seen = new Set<string>();
+
+  for (const text of texts) {
+    if (!text) continue;
+    for (const id of extractSlackUserMentionIds(text)) {
+      if (ignored.has(id) || seen.has(id)) continue;
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+
+  if (ids.length === 0) return {};
+
+  const entries = await Promise.all(
+    ids.map(
+      async (id): Promise<[string, string] | undefined> => {
+        try {
+          const label = await resolveLabel(id);
+          const sanitized = sanitizeOptionalLabel(label ?? undefined);
+          if (!sanitized || sanitized === id) return undefined;
+          return [id, sanitized];
+        } catch {
+          return undefined;
+        }
+      }
+    )
+  );
+
+  return Object.fromEntries(entries.filter((entry) => entry !== undefined));
+}
+
+function renderUserMention(
+  content: string,
+  options: RenderSlackTextOptions
+): string {
+  const id = content.slice(1);
+  if (!isSlackUserId(id)) {
+    return `<${content}>`;
+  }
+
+  const fallback = sanitizeLabel(options.userFallbackLabel, "unknown-user");
+  const label = sanitizeLabel(options.userLabels?.[id], fallback);
+  if (label === id) {
+    return `@${fallback}`;
+  }
+  return `@${label}`;
+}
+
+function renderChannelReference(
+  content: string,
+  options: RenderSlackTextOptions
+): string {
+  const [idWithPrefix, label] = splitSlackLabel(content);
+  const channelId = idWithPrefix.slice(1);
+  const fallback = sanitizeLabel(
+    options.channelFallbackLabel,
+    "unknown-channel"
+  );
+  const resolvedLabel = label ?? options.channelLabels?.[channelId];
+  return `#${sanitizeLabel(resolvedLabel, fallback)}`;
+}
+
+function renderSpecialReference(content: string): string {
+  if (
+    content === "!here" ||
+    content === "!channel" ||
+    content === "!everyone"
+  ) {
+    return `@${content.slice(1)}`;
+  }
+
+  const subteam = /^!subteam\^[^|>]+(?:\|(.+))?$/.exec(content);
+  if (subteam) {
+    return `@${sanitizeLabel(subteam[1], "usergroup")}`;
+  }
+
+  return `<${content}>`;
+}
+
+function renderLink(content: string): string {
+  const [url, label] = splitSlackLabel(content);
+  if (!label) {
+    return url;
+  }
+
+  return `${sanitizeLabel(label, url)} (${url})`;
+}
+
+function splitSlackLabel(content: string): [string, string | undefined] {
+  const separatorIndex = content.indexOf("|");
+  if (separatorIndex === -1) {
+    return [content, undefined];
+  }
+
+  return [content.slice(0, separatorIndex), content.slice(separatorIndex + 1)];
+}
+
+function sanitizeLabel(label: string | undefined, fallback: string): string {
+  const sanitized = label
+    ?.replace(/[<>]/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^[@#]+/, "")
+    .trim();
+
+  if (sanitized) {
+    return sanitized;
+  }
+
+  const sanitizedFallback = fallback
+    .replace(/[<>]/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^[@#]+/, "")
+    .trim();
+
+  return sanitizedFallback || "unknown";
+}
+
+function sanitizeOptionalLabel(label: string | undefined): string | undefined {
+  return label
+    ?.replace(/[<>]/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^[@#]+/, "")
+    .trim();
+}
+
+function stripLeadingExactToken(text: string, token: string): string {
+  const leadingWhitespaceLength = text.length - text.trimStart().length;
+  const afterWhitespace = text.slice(leadingWhitespaceLength);
+
+  if (!afterWhitespace.startsWith(token)) {
+    return text;
+  }
+
+  return afterWhitespace.slice(token.length).trimStart();
+}
+
+function isSlackUserId(value: string): boolean {
+  return /^[UW][A-Z0-9]+$/.test(value);
+}
+
+function looksLikeUrl(content: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\/\S+$/i.test(splitSlackLabel(content)[0]);
+}

package/node_modules/@vellumai/slack-text/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}