@vellumai/assistant 0.7.1 → 0.7.3

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

@@ -5,12 +5,7 @@ export interface RenderSlackTextOptions {
   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>();
@@ -27,30 +22,6 @@ export function extractSlackUserMentionIds(text: string): string[] {
   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 = {}
@@ -78,21 +49,15 @@ export function renderSlackTextForModel(
 
 export async function buildSlackUserLabelMap(
   texts: Iterable<string | undefined>,
-  resolveLabel: (userId: string) => Promise<string | undefined | null>,
-  options: BuildSlackUserLabelMapOptions = {}
+  resolveLabel: (userId: string) => Promise<string | undefined | null>
 ): 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;
+      if (seen.has(id)) continue;
       seen.add(id);
       ids.push(id);
     }
@@ -215,17 +180,6 @@ function sanitizeOptionalLabel(label: string | undefined): string | undefined {
     .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);
 }

package/node_modules/@vellumai/twilio-client/bun.lock

@@ -0,0 +1,24 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@vellumai/twilio-client",
+      "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/twilio-client/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@vellumai/twilio-client",
+  "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/twilio-client/src/__tests__/twilio-client.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  lookupIncomingPhoneNumberSid,
+  twilioAuthHeader,
+  twilioBaseUrl,
+  TwilioRestError,
+  updatePhoneNumberWebhooks,
+  type TwilioFetch,
+} from "../index.js";
+
+const ACCOUNT_SID = "AC123";
+const AUTH_TOKEN = "auth-token";
+const PHONE_NUMBER = "+15550100";
+const PHONE_NUMBER_SID = "PN123";
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    headers: { "Content-Type": "application/json" },
+    status,
+  });
+}
+
+describe("twilioAuthHeader", () => {
+  test("returns a Basic auth header", () => {
+    expect(twilioAuthHeader("AC_test_sid", "test_token")).toBe(
+      "Basic " + Buffer.from("AC_test_sid:test_token").toString("base64"),
+    );
+  });
+});
+
+describe("twilioBaseUrl", () => {
+  test("constructs the account-scoped REST API URL", () => {
+    expect(twilioBaseUrl("AC_abc123")).toBe(
+      "https://api.twilio.com/2010-04-01/Accounts/AC_abc123",
+    );
+  });
+});
+
+describe("lookupIncomingPhoneNumberSid", () => {
+  test("returns the matching incoming phone number SID", async () => {
+    const fetchImpl = mock<TwilioFetch>(async () =>
+      jsonResponse({
+        incoming_phone_numbers: [
+          { phone_number: "+15550199", sid: "PN_OTHER" },
+          { phone_number: PHONE_NUMBER, sid: PHONE_NUMBER_SID },
+        ],
+      }),
+    );
+
+    await expect(
+      lookupIncomingPhoneNumberSid({
+        accountSid: ACCOUNT_SID,
+        authToken: AUTH_TOKEN,
+        fetchImpl,
+        phoneNumber: PHONE_NUMBER,
+      }),
+    ).resolves.toBe(PHONE_NUMBER_SID);
+  });
+
+  test("throws TwilioRestError for lookup failures", async () => {
+    const fetchImpl = mock<TwilioFetch>(
+      async () => new Response("unavailable", { status: 503 }),
+    );
+
+    await expect(
+      lookupIncomingPhoneNumberSid({
+        accountSid: ACCOUNT_SID,
+        authToken: AUTH_TOKEN,
+        fetchImpl,
+        phoneNumber: PHONE_NUMBER,
+      }),
+    ).rejects.toBeInstanceOf(TwilioRestError);
+  });
+});
+
+describe("updatePhoneNumberWebhooks", () => {
+  test("looks up the SID and posts voice webhook settings", async () => {
+    const calls: Array<{ input: string | URL | Request; init?: RequestInit }> =
+      [];
+    const fetchImpl = mock<TwilioFetch>(
+      async (input: string | URL | Request, init?: RequestInit) => {
+        calls.push({ input, init });
+        if (calls.length === 1) {
+          return jsonResponse({
+            incoming_phone_numbers: [
+              { phone_number: PHONE_NUMBER, sid: PHONE_NUMBER_SID },
+            ],
+          });
+        }
+        return jsonResponse({});
+      },
+    );
+
+    await updatePhoneNumberWebhooks({
+      accountSid: ACCOUNT_SID,
+      authToken: AUTH_TOKEN,
+      fetchImpl,
+      phoneNumber: PHONE_NUMBER,
+      webhooks: {
+        statusCallbackUrl: "https://example.test/webhooks/twilio/status",
+        voiceUrl: "https://example.test/webhooks/twilio/voice",
+      },
+    });
+
+    expect(calls).toHaveLength(2);
+    expect(String(calls[0].input)).toContain(
+      `/Accounts/${ACCOUNT_SID}/IncomingPhoneNumbers.json?PhoneNumber=%2B15550100`,
+    );
+    expect(String(calls[1].input)).toContain(
+      `/Accounts/${ACCOUNT_SID}/IncomingPhoneNumbers/${PHONE_NUMBER_SID}.json`,
+    );
+    expect(calls[1].init?.method).toBe("POST");
+    expect(calls[1].init?.headers).toEqual({
+      Authorization:
+        "Basic " +
+        Buffer.from(`${ACCOUNT_SID}:${AUTH_TOKEN}`).toString("base64"),
+      "Content-Type": "application/x-www-form-urlencoded",
+    });
+    const body = new URLSearchParams(String(calls[1].init?.body));
+    expect(body.get("VoiceUrl")).toBe(
+      "https://example.test/webhooks/twilio/voice",
+    );
+    expect(body.get("StatusCallback")).toBe(
+      "https://example.test/webhooks/twilio/status",
+    );
+  });
+});

package/node_modules/@vellumai/twilio-client/src/index.ts

@@ -0,0 +1,179 @@
+export type TwilioFetch = (
+  input: string | URL | Request,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export interface TwilioCredentials {
+  accountSid: string;
+  authToken: string;
+}
+
+export interface TwilioRequestOptions {
+  fetchImpl?: TwilioFetch;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+export interface TwilioWebhookUrls {
+  voiceUrl: string;
+  statusCallbackUrl: string;
+}
+
+export interface TwilioRestErrorOptions {
+  cause?: unknown;
+  status?: number;
+}
+
+export class TwilioRestError extends Error {
+  readonly provider = "twilio";
+  readonly status?: number;
+
+  constructor(message: string, options: TwilioRestErrorOptions = {}) {
+    super(message, { cause: options.cause });
+    this.name = "TwilioRestError";
+    this.status = options.status;
+  }
+}
+
+interface IncomingPhoneNumbersResponse {
+  incoming_phone_numbers?: Array<{
+    phone_number?: string;
+    sid?: string;
+  }>;
+}
+
+function resolveFetch(fetchImpl?: TwilioFetch): TwilioFetch {
+  return fetchImpl ?? fetch;
+}
+
+function resolveSignal(input: TwilioRequestOptions): AbortSignal | undefined {
+  if (input.signal) return input.signal;
+  return typeof input.timeoutMs === "number"
+    ? AbortSignal.timeout(input.timeoutMs)
+    : undefined;
+}
+
+async function safeResponseText(response: Response): Promise<string> {
+  return await response.text().catch(() => "");
+}
+
+async function safeJson<T>(response: Response, context: string): Promise<T> {
+  try {
+    return (await response.json()) as T;
+  } catch (cause) {
+    throw new TwilioRestError(`Twilio API returned invalid JSON ${context}`, {
+      cause,
+      status: response.status,
+    });
+  }
+}
+
+export function twilioAuthHeader(
+  accountSid: string,
+  authToken: string,
+): string {
+  return (
+    "Basic " + Buffer.from(`${accountSid}:${authToken}`).toString("base64")
+  );
+}
+
+export function twilioBaseUrl(accountSid: string): string {
+  return `https://api.twilio.com/2010-04-01/Accounts/${accountSid}`;
+}
+
+export async function lookupIncomingPhoneNumberSid(
+  input: TwilioCredentials &
+    TwilioRequestOptions & {
+      phoneNumber: string;
+    },
+): Promise<string | undefined> {
+  const response = await resolveFetch(input.fetchImpl)(
+    `${twilioBaseUrl(
+      input.accountSid,
+    )}/IncomingPhoneNumbers.json?PhoneNumber=${encodeURIComponent(
+      input.phoneNumber,
+    )}`,
+    {
+      method: "GET",
+      headers: {
+        Authorization: twilioAuthHeader(input.accountSid, input.authToken),
+      },
+      signal: resolveSignal(input),
+    },
+  );
+
+  if (!response.ok) {
+    const detail = await safeResponseText(response);
+    throw new TwilioRestError(
+      `Twilio API error ${response.status} looking up phone number: ${detail}`,
+      { status: response.status },
+    );
+  }
+
+  const data = await safeJson<IncomingPhoneNumbersResponse>(
+    response,
+    "looking up phone number",
+  );
+  const match = data.incoming_phone_numbers?.find(
+    (number) => number.phone_number === input.phoneNumber && number.sid,
+  );
+  return match?.sid;
+}
+
+export async function updateIncomingPhoneNumberWebhooks(
+  input: TwilioCredentials &
+    TwilioRequestOptions & {
+      phoneNumberSid: string;
+      webhooks: TwilioWebhookUrls;
+    },
+): Promise<void> {
+  const body = new URLSearchParams({
+    VoiceUrl: input.webhooks.voiceUrl,
+    VoiceMethod: "POST",
+    StatusCallback: input.webhooks.statusCallbackUrl,
+    StatusCallbackMethod: "POST",
+  });
+
+  const response = await resolveFetch(input.fetchImpl)(
+    `${twilioBaseUrl(input.accountSid)}/IncomingPhoneNumbers/${
+      input.phoneNumberSid
+    }.json`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: twilioAuthHeader(input.accountSid, input.authToken),
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: body.toString(),
+      signal: resolveSignal(input),
+    },
+  );
+
+  if (!response.ok) {
+    const detail = await safeResponseText(response);
+    throw new TwilioRestError(
+      `Twilio API error ${response.status} updating webhooks: ${detail}`,
+      { status: response.status },
+    );
+  }
+}
+
+export async function updatePhoneNumberWebhooks(
+  input: TwilioCredentials &
+    TwilioRequestOptions & {
+      phoneNumber: string;
+      webhooks: TwilioWebhookUrls;
+    },
+): Promise<void> {
+  const phoneNumberSid = await lookupIncomingPhoneNumberSid(input);
+  if (!phoneNumberSid) {
+    throw new TwilioRestError(
+      `Phone number ${input.phoneNumber} not found on Twilio account ${input.accountSid}`,
+    );
+  }
+
+  await updateIncomingPhoneNumberWebhooks({
+    ...input,
+    phoneNumberSid,
+  });
+}

package/node_modules/@vellumai/twilio-client/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"]
+}