@vellumai/assistant 0.6.3 → 0.6.5

package/src/runtime/slack-block-formatting.ts

@@ -57,21 +57,62 @@ export function textToSlackBlocks(text: string): Block[] | undefined {
 
     if (segment.type === "code") {
       const lang = segment.lang ?? "";
-      const codeText = "```" + lang + "\n" + segment.content + "\n```";
-      blocks.push({
-        type: "section",
-        text: { type: "mrkdwn", text: codeText },
-      });
+      const codeChunks = splitCodeSegmentContent(segment.content, lang);
+      for (let c = 0; c < codeChunks.length; c++) {
+        if (c > 0) {
+          blocks.push({ type: "divider" });
+        }
+        blocks.push({
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: "```" + lang + "\n" + codeChunks[c] + "\n```",
+          },
+        });
+      }
     } else if (segment.type === "header") {
       blocks.push({
         type: "header",
         text: { type: "plain_text", text: segment.content },
       });
+    } else if (segment.type === "table") {
+      const structured = convertTableToStructuredText(
+        segment.headers,
+        segment.rows,
+      );
+      const mrkdwn = markdownToMrkdwn(structured);
+      const chunks = splitLongTextSegment(mrkdwn);
+      for (let c = 0; c < chunks.length; c++) {
+        if (c > 0) {
+          blocks.push({ type: "divider" });
+        }
+        blocks.push({
+          type: "section",
+          text: { type: "mrkdwn", text: chunks[c] },
+        });
+      }
     } else {
-      blocks.push({
-        type: "section",
-        text: { type: "mrkdwn", text: markdownToMrkdwn(segment.content) },
-      });
+      // Transform to Slack mrkdwn FIRST, then split. Splitting raw markdown
+      // can bisect `[link text](url)` spans or `**bold**` markers, leaving
+      // orphan tokens that `markdownToMrkdwn`'s regex won't match — raw
+      // markdown would then leak through to Slack. The splitter is also
+      // span-aware (see `splitLongTextSegment`) so candidate boundaries
+      // landing inside a `<url|text>` or `*bold*` span are rejected, which
+      // matters when link text contains `. `/`! `/`? ` (e.g.
+      // `<url|First sentence. Second sentence>`) or when a span straddles
+      // the maxChars window. The preceding table branch uses the same
+      // ordering.
+      const mrkdwn = markdownToMrkdwn(segment.content);
+      const chunks = splitLongTextSegment(mrkdwn);
+      for (let c = 0; c < chunks.length; c++) {
+        if (c > 0) {
+          blocks.push({ type: "divider" });
+        }
+        blocks.push({
+          type: "section",
+          text: { type: "mrkdwn", text: chunks[c] },
+        });
+      }
     }
   }
 
@@ -113,7 +154,13 @@ interface HeaderSegment {
   content: string;
 }
 
-type Segment = TextSegment | CodeSegment | HeaderSegment;
+interface TableSegment {
+  type: "table";
+  headers: string[];
+  rows: string[][];
+}
+
+type Segment = TextSegment | CodeSegment | HeaderSegment | TableSegment;
 
 function splitIntoSegments(text: string): Segment[] {
   const lines = text.split("\n");
@@ -155,6 +202,15 @@ function splitIntoSegments(text: string): Segment[] {
       continue;
     }
 
+    // Detect markdown tables: header row + separator row + data rows
+    const tableSegment = tryParseTable(lines, i);
+    if (tableSegment) {
+      flushText();
+      segments.push(tableSegment.segment);
+      i = tableSegment.nextIndex;
+      continue;
+    }
+
     currentTextLines.push(line);
     i++;
   }
@@ -163,6 +219,104 @@ function splitIntoSegments(text: string): Segment[] {
   return segments;
 }
 
+/**
+ * Parse cells from a pipe-delimited table row, trimming whitespace.
+ */
+function parseTableRow(line: string): string[] {
+  const ESCAPED_PIPE_PLACEHOLDER = "\x00PIPE\x00";
+  const ESCAPED_BACKSLASH_PLACEHOLDER = "\x00BSLASH\x00";
+  return line
+    // First, protect escaped backslashes (\\) so they don't interfere
+    .replace(/\\\\/g, ESCAPED_BACKSLASH_PLACEHOLDER)
+    // Now a remaining \| is a genuinely escaped pipe (odd backslash)
+    .replace(/\\\|/g, ESCAPED_PIPE_PLACEHOLDER)
+    .replace(/^\|/, "")
+    .replace(/\|$/, "")
+    .split("|")
+    .map((cell) =>
+      cell
+        .replaceAll(ESCAPED_PIPE_PLACEHOLDER, "|")
+        .replaceAll(ESCAPED_BACKSLASH_PLACEHOLDER, "\\\\")
+        .trim(),
+    );
+}
+
+/**
+ * Check if a line is a markdown table separator row (e.g., |---|---|).
+ */
+function isSeparatorRow(line: string): boolean {
+  return /^\|[\s:-]+(\|[\s:-]+)*\|?\s*$/.test(line);
+}
+
+/**
+ * Try to parse a markdown table starting at the given line index.
+ * Returns the parsed table segment and the next line index, or null
+ * if the lines don't form a valid table (header + separator + at least
+ * one data row).
+ */
+function tryParseTable(
+  lines: string[],
+  startIndex: number,
+): { segment: TableSegment; nextIndex: number } | null {
+  // Need at least 3 lines: header, separator, one data row
+  if (startIndex + 2 >= lines.length) return null;
+
+  const headerLine = lines[startIndex];
+  const separatorLine = lines[startIndex + 1];
+
+  // Header must be a pipe-delimited row
+  if (!headerLine.includes("|") || !headerLine.match(/^\|.*\|$/)) return null;
+  if (!isSeparatorRow(separatorLine)) return null;
+
+  const headers = parseTableRow(headerLine);
+
+  // Collect data rows
+  const rows: string[][] = [];
+  let i = startIndex + 2;
+  while (
+    i < lines.length &&
+    lines[i].includes("|") &&
+    lines[i].match(/^\|.*\|$/)
+  ) {
+    if (!isSeparatorRow(lines[i])) {
+      rows.push(parseTableRow(lines[i]));
+    }
+    i++;
+  }
+
+  // Need at least one data row to qualify as a table
+  if (rows.length === 0) return null;
+
+  return {
+    segment: { type: "table", headers, rows },
+    nextIndex: i,
+  };
+}
+
+/**
+ * Convert a parsed table into structured bullet-point text suitable
+ * for Slack rendering. Uses the first column as the entry label,
+ * listing remaining columns as sub-bullets.
+ */
+function convertTableToStructuredText(
+  headers: string[],
+  rows: string[][],
+): string {
+  const lines: string[] = [];
+
+  for (const row of rows) {
+    const label = row[0] ?? "";
+    lines.push(`**${label}**`);
+    for (let c = 1; c < headers.length; c++) {
+      const value = row[c] ?? "";
+      lines.push(`  - ${headers[c]}: ${value}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n").trim();
+}
+
 function markdownToMrkdwn(text: string): string {
   let result = text;
   // [text](url) → <url|text>
@@ -174,3 +328,276 @@ function markdownToMrkdwn(text: string): string {
   result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
   return result;
 }
+
+// ---------------------------------------------------------------------------
+// Long-text splitting
+// ---------------------------------------------------------------------------
+
+/**
+ * Slack's `section` block has a documented ~3000-character limit on the
+ * `text.text` value. Keep a margin under that so downstream transforms
+ * (e.g. `markdownToMrkdwn` expansions) don't push a chunk over.
+ */
+export const SLACK_SECTION_MAX_CHARS = 2800;
+
+/**
+ * Split `text` into chunks no larger than `maxChars`, preferring natural
+ * boundaries. Pure helper: no Block Kit knowledge, safe to unit test.
+ *
+ * Preference order for split points:
+ *  1. Paragraph boundary (`\n\n`)
+ *  2. Single newline (`\n`)
+ *  3. Sentence boundary (`. `, `! `, `? `)
+ *  4. Hard slice at `maxChars` (backed up to the start of any straddling
+ *     mrkdwn span, when possible)
+ *
+ * Span-aware: candidate boundaries that fall strictly inside a Slack
+ * `<...>` link/user token or a `*...*` bold span are rejected so chunks
+ * never end with an unclosed `<` or orphan `*`. This matters because
+ * `markdownToMrkdwn` runs before splitting, and link text can legitimately
+ * contain `. `/`! `/`? ` (e.g. `<url|First sentence. Second sentence>`).
+ *
+ * Short inputs (length ≤ `maxChars`) return `[text]` unchanged. Each chunk
+ * is trimmed of leading/trailing whitespace at chunk boundaries; interior
+ * whitespace is preserved.
+ */
+export function splitLongTextSegment(
+  text: string,
+  maxChars: number = SLACK_SECTION_MAX_CHARS,
+): string[] {
+  if (maxChars <= 0 || text.length <= maxChars) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > maxChars) {
+    const window = remaining.slice(0, maxChars);
+    const spans = computeMrkdwnSpans(window);
+    let splitAt = findBoundary(window, ["\n\n"], spans);
+    if (splitAt < 0) splitAt = findBoundary(window, ["\n"], spans);
+    if (splitAt < 0) splitAt = findBoundary(window, [". ", "! ", "? "], spans);
+    if (splitAt < 0) splitAt = hardSliceAvoidingSpans(maxChars, spans);
+
+    const chunk = remaining.slice(0, splitAt).trim();
+    if (chunk.length > 0) chunks.push(chunk);
+    remaining = remaining.slice(splitAt);
+  }
+
+  const tail = remaining.trim();
+  if (tail.length > 0) chunks.push(tail);
+
+  return chunks;
+}
+
+/**
+ * Slack link/mention tokens always start with one of these prefixes after
+ * the opening `<`. A plain `<` in technical prose (e.g. `a < b`) does not
+ * match any of these and must not be treated as a span start, or the
+ * splitter would reject every boundary past the `<` and fall back to a
+ * hard slice that can land mid-word.
+ */
+const SLACK_LINK_PREFIXES = [
+  "http://",
+  "https://",
+  "mailto:",
+  "#C", // channel ref: <#C0123ABCD|name>
+  "@U", // user mention: <@U0123ABCD>
+  "@W", // workspace user: <@W0123ABCD>
+  "!channel",
+  "!here",
+  "!everyone",
+  "!subteam",
+  "!date",
+];
+
+// Matches `scheme://` at the start of a string where `scheme` follows RFC 3986
+// syntax: `ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )`. Covers http, https,
+// ftp, ssh, git+ssh, custom app schemes, etc.
+const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+function looksLikeLinkStart(window: string, openIdx: number): boolean {
+  const rest = window.slice(openIdx + 1);
+  if (rest.length === 0) return false;
+  const first = rest.charCodeAt(0);
+  // Fast reject: whitespace or another `<` immediately after `<` is never a link.
+  if (first === 0x20 || first === 0x09 || first === 0x0a || first === 0x3c) {
+    return false;
+  }
+  for (const prefix of SLACK_LINK_PREFIXES) {
+    if (rest.startsWith(prefix)) return true;
+    // Near the window edge the prefix may be truncated — e.g. `<https`
+    // when `://` is past the cutoff. If `rest` is a strict prefix of a
+    // known link prefix, treat it as link-shaped so the continuation
+    // past the window is still protected from mid-token hard slicing.
+    if (rest.length < prefix.length && prefix.startsWith(rest)) return true;
+  }
+  // `markdownToMrkdwn` wraps any markdown link target in `<url|text>`,
+  // including schemes beyond the whitelist above (ftp, ssh, custom app
+  // schemes, etc.). Recognize any `scheme://` prefix so those spans are
+  // protected too. Also treat a truncated `<scheme` at the window edge as
+  // link-shaped so the continuation past the window is not hard-sliced.
+  if (URL_SCHEME_RE.test(rest)) return true;
+  const colonIdx = rest.indexOf(":");
+  if (colonIdx < 0) {
+    if (/^[a-z][a-z0-9+.-]*$/i.test(rest)) return true;
+  } else if (colonIdx + 1 === rest.length) {
+    if (/^[a-z][a-z0-9+.-]*:$/i.test(rest)) return true;
+  } else if (rest[colonIdx + 1] === "/" && colonIdx + 2 === rest.length) {
+    if (/^[a-z][a-z0-9+.-]*:\/$/i.test(rest)) return true;
+  }
+  return false;
+}
+
+/**
+ * Find half-open intervals `[start, end)` covering Slack mrkdwn spans in
+ * `window` that the splitter must not bisect: `<...>` link/mention tokens
+ * and `*...*` single-asterisk bold runs. A `<` is only treated as a span
+ * start when it is followed by a recognized Slack link/mention prefix
+ * (see `SLACK_LINK_PREFIXES`); plain `<` in technical text is skipped.
+ * An unclosed link-shaped `<...` is treated as a span extending to the
+ * end of the window so the splitter avoids landing inside a span that
+ * straddles the cutoff.
+ */
+function computeMrkdwnSpans(window: string): Array<[number, number]> {
+  const intervals: Array<[number, number]> = [];
+
+  let i = 0;
+  while (i < window.length) {
+    const open = window.indexOf("<", i);
+    if (open < 0) break;
+    if (!looksLikeLinkStart(window, open)) {
+      i = open + 1;
+      continue;
+    }
+    const close = window.indexOf(">", open + 1);
+    // For unclosed `<...` (span continues past the window), use a sentinel
+    // larger than any in-window position so split-point checks treat the
+    // window's right edge as inside the span and back the hard-slice up.
+    const end = close < 0 ? window.length + 1 : close + 1;
+    intervals.push([open, end]);
+    i = close < 0 ? window.length : end;
+  }
+
+  // Bold spans cannot contain `*` or `\n`.
+  const boldRe = /\*[^*\n]+\*/g;
+  let m: RegExpExecArray | null;
+  while ((m = boldRe.exec(window)) !== null) {
+    intervals.push([m.index, m.index + m[0].length]);
+  }
+
+  return intervals;
+}
+
+function isInsideSpan(
+  pos: number,
+  spans: Array<[number, number]>,
+): boolean {
+  for (const [start, end] of spans) {
+    if (pos > start && pos < end) return true;
+  }
+  return false;
+}
+
+function hardSliceAvoidingSpans(
+  maxChars: number,
+  spans: Array<[number, number]>,
+): number {
+  for (const [start, end] of spans) {
+    if (maxChars > start && maxChars < end) {
+      // Back up to the start of the straddling span so it stays intact in
+      // the next chunk. If the span starts at 0, we have no choice but to
+      // hard-slice through it.
+      return start > 0 ? start : maxChars;
+    }
+  }
+  return maxChars;
+}
+
+/**
+ * Split a code segment's inner content into chunks that, once wrapped in
+ * ```lang … ``` fences, each fit inside Slack's section-text limit.
+ *
+ * Prefers line boundaries so code stays readable across chunks; falls back
+ * to a hard character slice for pathological single-line content.
+ */
+export function splitCodeSegmentContent(
+  content: string,
+  lang: string = "",
+  maxChars: number = SLACK_SECTION_MAX_CHARS,
+): string[] {
+  // Fence overhead: "```" + lang + "\n" + content + "\n```"
+  const overhead = 3 + lang.length + 1 + 1 + 3;
+  const budget = maxChars - overhead;
+  if (budget <= 0 || content.length <= budget) return [content];
+
+  const chunks: string[] = [];
+  const lines = content.split("\n");
+  let current: string[] = [];
+  let currentLen = 0;
+
+  const flush = (): void => {
+    if (current.length > 0) {
+      chunks.push(current.join("\n"));
+      current = [];
+      currentLen = 0;
+    }
+  };
+
+  for (const line of lines) {
+    // +1 for the joining "\n" (only if current is non-empty)
+    const added = current.length === 0 ? line.length : line.length + 1;
+    if (currentLen + added <= budget) {
+      current.push(line);
+      currentLen += added;
+      continue;
+    }
+
+    flush();
+
+    // A single line longer than the budget — hard-slice it across chunks.
+    if (line.length > budget) {
+      let remaining = line;
+      while (remaining.length > budget) {
+        chunks.push(remaining.slice(0, budget));
+        remaining = remaining.slice(budget);
+      }
+      if (remaining.length > 0) {
+        current.push(remaining);
+        currentLen = remaining.length;
+      }
+    } else {
+      current.push(line);
+      currentLen = line.length;
+    }
+  }
+
+  flush();
+  return chunks;
+}
+
+/**
+ * Return the end index of the last occurrence of any delimiter in `window`
+ * whose split point does not fall inside a mrkdwn span. Returns -1 if no
+ * delimiter has a valid split point.
+ */
+function findBoundary(
+  window: string,
+  delimiters: string[],
+  spans: Array<[number, number]> = [],
+): number {
+  let best = -1;
+  for (const delim of delimiters) {
+    let from = window.length;
+    while (from > 0) {
+      const idx = window.lastIndexOf(delim, from - 1);
+      if (idx < 0) break;
+      const end = idx + delim.length;
+      if (!isInsideSpan(end, spans)) {
+        if (end > best) best = end;
+        break;
+      }
+      from = idx;
+    }
+  }
+  return best;
+}

package/src/schedule/scheduler.ts

@@ -1,3 +1,5 @@
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getConversation } from "../memory/conversation-crud.js";
 import { invalidateAssistantInferredItemsForConversation } from "../memory/task-memory-cleanup.js";
@@ -24,6 +26,13 @@ const log = getLogger("scheduler");
 export interface ScheduleMessageOptions {
   trustClass?: "guardian" | "trusted_contact" | "unknown";
   taskRunId?: string;
+  /**
+   * Optional LLM call-site identifier propagated to the per-call provider
+   * config. Schedule and sequence callers will start passing their own call-site
+   * (e.g. for a future scheduled-agent profile) once PRs 7-11 migrate them off
+   * the default `mainAgent` route.
+   */
+  callSite?: LLMCallSite;
 }
 
 export type ScheduleMessageProcessor = (
@@ -141,11 +150,21 @@ async function runScheduleOnce(
         });
         if (isOneShot) {
           completeOneShot(job.id);
+          emitScheduleFeedEvent({
+            title: job.name,
+            summary: "Reminder fired.",
+            dedupKey: `schedule-notify-oneshot:${job.id}`,
+          });
         } else {
           // Track recurring notify-mode success so lastStatus resets to ok
           // and retryCount clears after a transient failure.
           const runId = createScheduleRun(job.id, `notify-ok:${job.id}`);
           completeScheduleRun(runId, { status: "ok" });
+          emitScheduleFeedEvent({
+            title: job.name,
+            summary: "Scheduled notification fired.",
+            dedupKey: `schedule-run:${runId}`,
+          });
         }
       } catch (err) {
         log.warn(
@@ -223,6 +242,11 @@ async function runScheduleOnce(
           completeScheduleRun(runId, { status: "ok" });
           if (!job.quiet) {
             notifySchedule({ id: job.id, name: job.name });
+            emitScheduleFeedEvent({
+              title: job.name,
+              summary: "Scheduled task ran.",
+              dedupKey: `schedule-run:${runId}`,
+            });
           }
           if (isOneShot) completeOneShot(job.id);
         }
@@ -317,6 +341,11 @@ async function runScheduleOnce(
       completeScheduleRun(runId, { status: "ok" });
       if (!job.quiet) {
         notifySchedule({ id: job.id, name: job.name });
+        emitScheduleFeedEvent({
+          title: job.name,
+          summary: isOneShot ? "One-shot reminder ran." : "Scheduled job ran.",
+          dedupKey: `schedule-run:${runId}`,
+        });
       }
       if (isOneShot) completeOneShot(job.id);
       processed += 1;
@@ -384,3 +413,32 @@ async function runScheduleOnce(
   }
   return processed;
 }
+
+/**
+ * Fire-and-forget home-feed emit for a successful schedule run.
+ *
+ * Wraps {@link emitFeedEvent} with local error handling so a schema
+ * failure or writer hiccup can never interrupt the scheduler tick
+ * loop. The dedupKey is always derived from the schedule run id (or
+ * the job id, for one-shot notify-mode which fires before a run
+ * record is created) so each run lands as its own entry in the
+ * activity log — the writer's per-source cap keeps total volume
+ * bounded.
+ */
+function emitScheduleFeedEvent(params: {
+  title: string;
+  summary: string;
+  dedupKey: string;
+}): void {
+  void emitFeedEvent({
+    source: "assistant",
+    title: params.title,
+    summary: params.summary,
+    dedupKey: params.dedupKey,
+  }).catch((err) => {
+    log.warn(
+      { err, dedupKey: params.dedupKey },
+      "Failed to emit schedule feed event",
+    );
+  });
+}

package/src/security/__tests__/provider-key-env-fallback.test.ts

@@ -0,0 +1,119 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mock logger before importing any code that uses it.
+// ---------------------------------------------------------------------------
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports under test
+// ---------------------------------------------------------------------------
+
+import { _setStorePath } from "../encrypted-store.js";
+import { _resetBackend, getProviderKeyAsync } from "../secure-keys.js";
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-provkey-envfallback-${randomBytes(4).toString("hex")}`,
+);
+const STORE_PATH = join(TEST_DIR, "keys.enc");
+
+/**
+ * Regression test for the env-var fallback in `getProviderKeyAsync`.
+ *
+ * PR #27126 introduced `getLlmProviderEnvVar` which is LLM-scoped only.
+ * After that PR, calls like `getProviderKeyAsync("brave")` and
+ * `getProviderKeyAsync("perplexity")` stopped resolving the env var when
+ * the secure store was empty, breaking web-search for users with
+ * env-var-sourced Brave/Perplexity keys. The fix (this PR) routes the
+ * fallback through `getAnyProviderEnvVar` which consults both the LLM
+ * catalog and the search-provider map.
+ */
+describe("getProviderKeyAsync env-var fallback (regression #27126)", () => {
+  const SAVED_ENV: Record<string, string | undefined> = {};
+  const MANAGED_VARS = [
+    "BRAVE_API_KEY",
+    "PERPLEXITY_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+  ];
+
+  beforeEach(() => {
+    // Fresh encrypted store (no saved credentials → forces env-var fallback).
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    _setStorePath(STORE_PATH);
+    _resetBackend();
+
+    // Snapshot env so each test starts clean.
+    for (const name of MANAGED_VARS) {
+      SAVED_ENV[name] = process.env[name];
+      delete process.env[name];
+    }
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    _resetBackend();
+    for (const name of MANAGED_VARS) {
+      const saved = SAVED_ENV[name];
+      if (saved === undefined) {
+        delete process.env[name];
+      } else {
+        process.env[name] = saved;
+      }
+    }
+  });
+
+  afterAll(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  test("returns BRAVE_API_KEY from process.env when secure store is empty", async () => {
+    process.env.BRAVE_API_KEY = "brave-env-test";
+    expect(await getProviderKeyAsync("brave")).toBe("brave-env-test");
+  });
+
+  test("returns PERPLEXITY_API_KEY from process.env when secure store is empty", async () => {
+    process.env.PERPLEXITY_API_KEY = "pplx-env-test";
+    expect(await getProviderKeyAsync("perplexity")).toBe("pplx-env-test");
+  });
+
+  test("returns ANTHROPIC_API_KEY from process.env when secure store is empty (LLM regression)", async () => {
+    process.env.ANTHROPIC_API_KEY = "anthropic-env-test";
+    expect(await getProviderKeyAsync("anthropic")).toBe("anthropic-env-test");
+  });
+
+  test("returns OPENAI_API_KEY from process.env when secure store is empty (LLM regression)", async () => {
+    process.env.OPENAI_API_KEY = "openai-env-test";
+    expect(await getProviderKeyAsync("openai")).toBe("openai-env-test");
+  });
+
+  test("returns undefined for unknown provider even if any env var is set", async () => {
+    process.env.BRAVE_API_KEY = "brave-env-test";
+    expect(await getProviderKeyAsync("unknown-provider")).toBeUndefined();
+  });
+
+  test("returns undefined for keyless ollama even if env has unrelated keys", async () => {
+    process.env.BRAVE_API_KEY = "brave-env-test";
+    expect(await getProviderKeyAsync("ollama")).toBeUndefined();
+  });
+});