@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/plugins/defaults/memory-v3-shadow/pool-select.test.ts

@@ -1,146 +0,0 @@
-/**
- * Tests for `pool-select.ts` `selectPool` — focused on error SURFACING:
- *   - a provider call that THROWS on every attempt surfaces the underlying
- *     provider error (e.g. an upstream HTTP 4xx) in the thrown
- *     `MemoryV3RetrievalUnavailableError` message, rather than the generic
- *     "no usable selection" string that hid it;
- *   - a 200 response carrying no usable `tool_use` still throws the generic
- *     "no usable selection" message;
- *   - happy paths preserved: explicit ids → selection, omitted ids → keepAll,
- *     empty pool → [].
- *
- * `mock.module` is process-global and leaks into sibling files in a directory
- * run, so the provider-send-message stub DELEGATES to the real implementation
- * (keeping the real `extractToolUse`) unless this test is actively running
- * (`selectMockActive`) — mirrors `prune.test.ts` / `ever-injected-store.test.ts`.
- */
-
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type {
-  ContentBlock,
-  Provider,
-  ProviderResponse,
-} from "../../../providers/types.js";
-import type { MemoryRoutingTurn, Slug } from "./types.js";
-
-const realProviderSend = {
-  ...(await import("../../../providers/provider-send-message.js")),
-};
-
-let selectMockActive = false;
-let sendMessageImpl: (() => Promise<ProviderResponse>) | null = null;
-
-const mockProvider = {
-  name: "mock-memory-v3-selector",
-  async sendMessage(): Promise<ProviderResponse> {
-    if (!sendMessageImpl) throw new Error("sendMessageImpl not configured");
-    return sendMessageImpl();
-  },
-} as unknown as Provider;
-
-mock.module("../../../providers/provider-send-message.js", () => ({
-  ...realProviderSend,
-  getConfiguredProvider: (
-    ...args: Parameters<typeof realProviderSend.getConfiguredProvider>
-  ) =>
-    selectMockActive
-      ? Promise.resolve(mockProvider)
-      : realProviderSend.getConfiguredProvider(...args),
-}));
-
-const { MemoryV3RetrievalUnavailableError, selectPool } =
-  await import("./pool-select.js");
-
-function response(content: ContentBlock[]): ProviderResponse {
-  return {
-    content,
-    model: "mock",
-    usage: { inputTokens: 0, outputTokens: 0 },
-  } as ProviderResponse;
-}
-
-const turn: MemoryRoutingTurn = {
-  conversationId: "conv-1",
-  turnNumber: 0,
-  currentMessage: "echo something back",
-  recentContext: "",
-};
-
-const pool = {
-  stable: [],
-  finder: [{ slug: "page-a" as Slug, descriptor: "a descriptor" }],
-};
-
-describe("selectPool", () => {
-  beforeEach(() => {
-    selectMockActive = true;
-    sendMessageImpl = null;
-  });
-  afterAll(() => {
-    selectMockActive = false;
-  });
-
-  test("a provider throw surfaces the underlying error in the thrown message", async () => {
-    const upstream = "Together AI API error (400): 400 status code (no body)";
-    sendMessageImpl = async () => {
-      throw new Error(upstream);
-    };
-    let caught: unknown;
-    try {
-      await selectPool(pool, turn);
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
-    expect((caught as Error).message).toContain(
-      "provider call failed after retries",
-    );
-    // The real upstream error is no longer hidden behind the generic message.
-    expect((caught as Error).message).toContain(upstream);
-  });
-
-  test("a 200 with no usable tool_use throws the generic message", async () => {
-    sendMessageImpl = async () =>
-      response([{ type: "text", text: "I cannot call the tool." }]);
-    let caught: unknown;
-    try {
-      await selectPool(pool, turn);
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(MemoryV3RetrievalUnavailableError);
-    expect((caught as Error).message).toBe(
-      "memory-v3 pool selector returned no usable selection after retries",
-    );
-  });
-
-  test("explicit ids select the matching candidates", async () => {
-    sendMessageImpl = async () =>
-      response([
-        {
-          type: "tool_use",
-          id: "call-1",
-          name: "select_pages",
-          input: { ids: [1] },
-        },
-      ]);
-    expect(await selectPool(pool, turn)).toEqual([
-      { slug: "page-a", pinned: false },
-    ]);
-  });
-
-  test("omitted ids keep all candidates (recall-safe)", async () => {
-    sendMessageImpl = async () =>
-      response([
-        { type: "tool_use", id: "call-1", name: "select_pages", input: {} },
-      ]);
-    expect(await selectPool(pool, turn)).toEqual([
-      { slug: "page-a", pinned: false },
-    ]);
-  });
-
-  test("an empty candidate pool returns no selections", async () => {
-    expect(await selectPool({ stable: [], finder: [] }, turn)).toEqual([]);
-  });
-});

package/src/plugins/surface-import.ts

@@ -1,121 +0,0 @@
-/**
- * Shared low-level import machinery for user-surface files (plugin tools,
- * plugin hooks, and standalone workspace hooks).
- *
- * Both the plugin/tool cache (`mtime-cache.ts`) and the hook cache
- * (`../hooks/hook-loader.ts`) re-import surface files keyed by mtime. This
- * module owns the pieces they share — mtime stat, the per-process import
- * timeout, and a timeout-guarded, concurrency-deduplicated dynamic import —
- * so neither surface duplicates the logic and the import-timeout knob is
- * configured in exactly one place.
- *
- * Kept dependency-light (only the logger and `importDefault`) so it can sit
- * below both caches without introducing an import cycle.
- */
-
-import { statSync } from "node:fs";
-
-import { getLogger } from "../util/logger.js";
-import { importDefault } from "./external-plugin-loader.js";
-
-const log = getLogger("surface-import");
-
-/**
- * Per-process upper bound on how long a single surface import may take.
- * Set once at boot by `populateCacheAtBoot`; read by every re-import. A
- * plugin/hook with a hanging top-level `await` is skipped rather than
- * blocking the daemon.
- */
-let importTimeoutMs = 10_000;
-
-/** Override the surface import timeout (called once at boot). */
-export function setSurfaceImportTimeout(ms: number): void {
-  importTimeoutMs = ms;
-}
-
-/** Current surface import timeout in milliseconds. */
-export function getSurfaceImportTimeout(): number {
-  return importTimeoutMs;
-}
-
-/**
- * Get the mtimeMs of a file, or 0 if the file doesn't exist or can't be
- * stat'd. Callers treat 0 as "absent" (cache-evict / skip).
- */
-export function getMtime(filePath: string): number {
-  try {
-    return statSync(filePath).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * In-flight import promises, keyed by file path. Prevents duplicate
- * `import()` calls when multiple readers request the same surface
- * concurrently.
- */
-const inflight = new Map<string, Promise<unknown>>();
-
-/**
- * Import a module's default export with a timeout. If the import doesn't
- * resolve within `timeoutMs`, logs a warning and returns `undefined` so a
- * hanging module doesn't block daemon startup indefinitely. Defaults to the
- * module-level {@link getSurfaceImportTimeout}.
- */
-export async function importWithTimeout<T>(
-  filePath: string,
-  timeoutMs: number = importTimeoutMs,
-): Promise<T | undefined> {
-  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
-  try {
-    const timeoutSentinel = Symbol("import-timeout");
-    const importPromise = importWithDedup<T>(filePath);
-    const timeoutPromise = new Promise<typeof timeoutSentinel>((resolve) => {
-      timeoutHandle = setTimeout(() => resolve(timeoutSentinel), timeoutMs);
-    });
-    const result = await Promise.race([importPromise, timeoutPromise]);
-    if (result === timeoutSentinel) {
-      importPromise.catch(() => {
-        /* swallow — late rejection from abandoned import */
-      });
-      log.warn(
-        { filePath, timeoutMs },
-        `Import timed out after ${timeoutMs}ms — skipping surface`,
-      );
-      return undefined;
-    }
-    return result as T;
-  } finally {
-    if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
-  }
-}
-
-/**
- * Import a module's default export, deduplicating concurrent imports for
- * the same file path. This prevents two readers from triggering duplicate
- * `import()` calls when they request the same surface simultaneously.
- *
- * Note: Bun caches `import()` by resolved path within a process and does not
- * bust on query-string or hash changes, so the dedup is about avoiding
- * redundant async work, not cache-busting. A content edit to an existing
- * file is only picked up after a process restart (added and removed files
- * are picked up live, since discovery is by directory listing).
- */
-async function importWithDedup<T>(filePath: string): Promise<T> {
-  let promise = inflight.get(filePath);
-  if (promise === undefined) {
-    promise = importDefault<T>(filePath);
-    inflight.set(filePath, promise);
-  }
-  try {
-    return (await promise) as T;
-  } finally {
-    inflight.delete(filePath);
-  }
-}
-
-/** Clear in-flight import state. Test-only. */
-export function clearSurfaceImportInflight(): void {
-  inflight.clear();
-}

package/src/providers/openai/__tests__/api-error-normalization.test.ts

@@ -1,321 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type OpenAI from "openai";
-
-import {
-  captureRawErrorBodyFetch,
-  formatNormalizedOpenAIAPIError,
-  normalizeOpenAIAPIError,
-} from "../api-error-normalization.js";
-
-/**
- * Stand-in for an `OpenAI.APIError`. The real SDK constructor stringifies the
- * body into `.message` and renders unparseable bodies as "(no body)" — exactly
- * the lossy behavior we work around by capturing the raw body separately — so
- * the tests pass the raw body explicitly the way the provider does.
- */
-function apiError(
-  status: number,
-  opts: { message?: string; sdkBody?: unknown; headers?: Headers } = {},
-): InstanceType<typeof OpenAI.APIError> {
-  return {
-    status,
-    message: opts.message ?? `${status} status code (no body)`,
-    headers: opts.headers ?? new Headers(),
-    error: opts.sdkBody,
-  } as unknown as InstanceType<typeof OpenAI.APIError>;
-}
-
-describe("normalizeOpenAIAPIError", () => {
-  test("surfaces Django {detail} bodies the SDK would drop", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400),
-      JSON.stringify({
-        detail: "Model 'MiniMax-M3' is not yet supported on Vellum.",
-      }),
-    );
-    expect(n.message).toBe(
-      "Model 'MiniMax-M3' is not yet supported on Vellum.",
-    );
-    expect(formatNormalizedOpenAIAPIError("Together AI", 400, n)).toBe(
-      "Together AI API error (400): Model 'MiniMax-M3' is not yet supported on Vellum.",
-    );
-  });
-
-  test("extracts OpenAI-shaped error metadata", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(401),
-      JSON.stringify({
-        error: {
-          message: "Invalid API key provided",
-          code: "invalid_api_key",
-          type: "invalid_request_error",
-          param: "api_key",
-        },
-      }),
-    );
-    expect(n).toMatchObject({
-      message: "Invalid API key provided",
-      apiErrorCode: "invalid_api_key",
-      apiErrorType: "invalid_request_error",
-      apiErrorParam: "api_key",
-    });
-    expect(formatNormalizedOpenAIAPIError("OpenAI", 401, n)).toContain(
-      "code=invalid_api_key; type=invalid_request_error; param=api_key",
-    );
-  });
-
-  test("promotes OpenRouter metadata.raw over the generic wrapper message", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400, {
-        sdkBody: {
-          error: {
-            code: 400,
-            message: "Provider returned error",
-            metadata: {
-              raw: "messages.4: tool_use_id must reference a prior tool_use block",
-              provider_name: "Anthropic",
-            },
-          },
-        },
-      }),
-    );
-    expect(n.message).toBe(
-      "messages.4: tool_use_id must reference a prior tool_use block",
-    );
-    expect(n.detail).toBe("provider=Anthropic");
-    expect(n.apiErrorCode).toBe("400");
-  });
-
-  test("prefers the captured raw body over the SDK's parsed error", () => {
-    // SDK collapsed the body; raw body still has the real detail.
-    const n = normalizeOpenAIAPIError(
-      apiError(400, { sdkBody: {} }),
-      JSON.stringify({ detail: "managed proxy rejected model" }),
-    );
-    expect(n.message).toBe("managed proxy rejected model");
-  });
-
-  test("falls back to the SDK-parsed error when the captured JSON was truncated", () => {
-    // encodeCapturedBody slices oversized bodies, which can leave an invalid
-    // JSON prefix. Rather than render that fragment (and lose metadata), fall
-    // back to the body the SDK already parsed from the full response.
-    const truncated =
-      '{"error":{"message":"too long","code":"context_length_exceeded","type":"invalid_request_error","param":"messag';
-    const n = normalizeOpenAIAPIError(
-      apiError(400, {
-        sdkBody: {
-          error: {
-            message: "too long",
-            code: "context_length_exceeded",
-            type: "invalid_request_error",
-            param: "messages",
-          },
-        },
-      }),
-      truncated,
-    );
-    expect(n.message).toBe("too long");
-    expect(n.apiErrorCode).toBe("context_length_exceeded");
-    expect(n.apiErrorType).toBe("invalid_request_error");
-    expect(n.apiErrorParam).toBe("messages");
-  });
-
-  test("uses a plain-text raw body when JSON parsing fails", () => {
-    const n = normalizeOpenAIAPIError(apiError(502), "upstream timeout");
-    expect(n.message).toBe("upstream timeout");
-  });
-
-  test("reads the upstream request id from headers", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400, { headers: new Headers({ "x-request-id": "req_abc123" }) }),
-      JSON.stringify({ detail: "bad request" }),
-    );
-    expect(n.requestId).toBe("req_abc123");
-    expect(formatNormalizedOpenAIAPIError("OpenAI", 400, n)).toContain(
-      "request_id=req_abc123",
-    );
-  });
-
-  test("falls back to x-openrouter-request-id", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400, {
-        headers: new Headers({ "x-openrouter-request-id": "gen-or-xyz" }),
-      }),
-      JSON.stringify({ detail: "bad request" }),
-    );
-    expect(n.requestId).toBe("gen-or-xyz");
-  });
-
-  test("truncates very long details with an ellipsis", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400),
-      JSON.stringify({ detail: "X".repeat(5000) }),
-    );
-    expect(n.message.length).toBeLessThanOrEqual(2001);
-    expect(n.message.endsWith("…")).toBe(true);
-  });
-
-  test("degrades to the status-stripped SDK message when there is no body", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(500, { message: "500 Internal Server Error" }),
-    );
-    expect(n.message).toBe("Internal Server Error");
-  });
-
-  test("falls back to 'Request failed' for the SDK '(no body)' sentinel", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(500, { message: "500 status code (no body)" }),
-    );
-    expect(n.message).toBe("Request failed");
-  });
-
-  test("surfaces the verbatim captured body as rawBody for downstream persistence", () => {
-    const raw = JSON.stringify({ detail: "model gone", extra: "kept" });
-    const n = normalizeOpenAIAPIError(apiError(400), raw);
-    // Extracted message is the clean detail...
-    expect(n.message).toBe("model gone");
-    // ...but the raw body is carried verbatim so the Raw tab can show it all.
-    expect(n.rawBody).toBe(raw);
-  });
-
-  test("keeps sibling code/type/param when the body is {error: <string>}", () => {
-    const n = normalizeOpenAIAPIError(
-      apiError(400),
-      JSON.stringify({
-        error: "bad request",
-        code: "context_length_exceeded",
-        type: "invalid_request_error",
-      }),
-    );
-    expect(n.message).toBe("bad request");
-    expect(n.apiErrorCode).toBe("context_length_exceeded");
-    expect(n.apiErrorType).toBe("invalid_request_error");
-  });
-});
-
-describe("captureRawErrorBodyFetch", () => {
-  // The fetch wrapper stashes the dropped body in a WeakMap keyed by the
-  // response's headers object — which the SDK passes through to
-  // APIError.headers — so normalize() recovers it with no explicit rawBody
-  // argument and nothing is written to a (loggable) header.
-  function fakeFetch(body: string, status: number): typeof globalThis.fetch {
-    return (async () =>
-      new Response(body, { status })) as unknown as typeof globalThis.fetch;
-  }
-
-  function errFor(res: Response, status: number) {
-    return {
-      status,
-      message: `${status} status code (no body)`,
-      headers: res.headers,
-      error: undefined,
-    } as unknown as InstanceType<typeof import("openai").APIError>;
-  }
-
-  test("recovers a non-2xx body into normalize() via the headers WeakMap", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = fakeFetch(JSON.stringify({ detail: "model gone" }), 400);
-    try {
-      const res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      // No rawBody arg: normalize recovers the body keyed by res.headers alone.
-      expect(normalizeOpenAIAPIError(errFor(res, 400)).message).toBe(
-        "model gone",
-      );
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
-
-  test("never writes the captured body to a header", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = fakeFetch(JSON.stringify({ detail: "secret" }), 400);
-    try {
-      const res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      const headerNames = [...res.headers.keys()];
-      expect(headerNames.some((h) => h.includes("vellum"))).toBe(false);
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
-
-  test("passes OK responses through untouched", async () => {
-    const original = globalThis.fetch;
-    globalThis.fetch = fakeFetch("ok", 200);
-    try {
-      const res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      expect(await res.text()).toBe("ok");
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
-
-  test("recovers (truncated) detail for oversized terminal errors", async () => {
-    const big = "y".repeat(40_000);
-    const original = globalThis.fetch;
-    globalThis.fetch = fakeFetch(JSON.stringify({ detail: big }), 400);
-    try {
-      const res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      const n = normalizeOpenAIAPIError(errFor(res, 400));
-      // The captured body is bounded (16 KB) and the message re-truncated to
-      // MAX_DETAIL_CHARS, so an oversized error can't balloon either.
-      expect(n.message).toContain("yyyy");
-      expect(n.message.length).toBeLessThanOrEqual(2001);
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
-
-  test("does not drain SDK-retryable bodies (408/409/429/5xx)", async () => {
-    const original = globalThis.fetch;
-    // Mirror the full SDK retry predicate, not just 429/5xx.
-    for (const status of [408, 409, 429, 500, 503]) {
-      globalThis.fetch = fakeFetch(
-        JSON.stringify({ detail: "retry me" }),
-        status,
-      );
-      try {
-        const res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-        // Pass-through: nothing captured, and the body is still readable by the
-        // SDK (we never consumed it).
-        expect(normalizeOpenAIAPIError(errFor(res, status)).message).not.toBe(
-          "retry me",
-        );
-        expect(res.status).toBe(status);
-        expect(await res.text()).toContain("retry me");
-      } finally {
-        globalThis.fetch = original;
-      }
-    }
-  });
-
-  test("honors the x-should-retry header override", async () => {
-    const original = globalThis.fetch;
-    const withHeader = (
-      status: number,
-      value: string,
-    ): typeof globalThis.fetch =>
-      (async () =>
-        new Response(JSON.stringify({ detail: "header says so" }), {
-          status,
-          headers: { "x-should-retry": value },
-        })) as unknown as typeof globalThis.fetch;
-    try {
-      // x-should-retry:true on an otherwise-terminal 400 → SDK retries → skip.
-      globalThis.fetch = withHeader(400, "true");
-      let res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      expect(normalizeOpenAIAPIError(errFor(res, 400)).message).not.toBe(
-        "header says so",
-      );
-
-      // x-should-retry:false on a 500 → SDK won't retry → capture it.
-      globalThis.fetch = withHeader(500, "false");
-      res = await captureRawErrorBodyFetch("https://x/v1/chat", {});
-      expect(normalizeOpenAIAPIError(errFor(res, 500)).message).toBe(
-        "header says so",
-      );
-    } finally {
-      globalThis.fetch = original;
-    }
-  });
-});