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

package/src/config/__tests__/platform-identity.test.ts

@@ -1,255 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import {
-  getPlatformBaseUrl,
-  setPlatformAssistantId,
-  setPlatformBaseUrl,
-  setPlatformOrganizationId,
-  setPlatformUserId,
-} from "../env.js";
-
-const actualSecureKeys = await import("../../security/secure-keys.js");
-mock.module("../../security/secure-keys.js", () => ({
-  ...actualSecureKeys,
-  getSecureKeyAsync: async () => undefined,
-}));
-
-const {
-  _resetPlatformIdentityEnsureForTests,
-  fetchPlatformIdentityIds,
-  PLATFORM_IDENTITY_VALIDATE_PATH,
-  resolvePlatformAssistantId,
-} = await import("../platform-identity.js");
-
-const BASE_URL = "https://platform.vellum.ai";
-const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
-const ORG_ID = "22222222-3333-4444-8555-666666666666";
-const USER_ID = "33333333-4444-4555-8666-777777777777";
-
-describe("fetchPlatformIdentityIds", () => {
-  const originalFetch = globalThis.fetch;
-  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
-  let fetchImpl: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response> = async () =>
-    new Response("not found", { status: 404 });
-
-  beforeEach(() => {
-    fetchCalls.length = 0;
-    fetchImpl = async () => new Response("not found", { status: 404 });
-    globalThis.fetch = (async (
-      input: RequestInfo | URL,
-      init?: RequestInit,
-    ) => {
-      const url = typeof input === "string" ? input : input.toString();
-      fetchCalls.push({ url, init });
-      return fetchImpl(input, init);
-    }) as unknown as typeof fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  test("returns the three ids from a successful validate response", async () => {
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-          name: "Example Assistant",
-        }),
-        { status: 200 },
-      );
-
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toEqual({
-      assistantId: ASSISTANT_ID,
-      organizationId: ORG_ID,
-      userId: USER_ID,
-    });
-    expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
-    );
-    expect(fetchCalls[0]?.init?.method).toBe("POST");
-    const headers = new Headers(fetchCalls[0]?.init?.headers);
-    expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
-  });
-
-  test("strips a trailing slash from the base URL", async () => {
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await fetchPlatformIdentityIds(`${BASE_URL}/`, "assistant-key");
-    expect(fetchCalls[0]?.url).toBe(
-      `${BASE_URL}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
-    );
-  });
-
-  test("returns null on 401 without throwing", async () => {
-    fetchImpl = async () => new Response("no", { status: 401 });
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toBeNull();
-  });
-
-  test("returns null on a network error without throwing", async () => {
-    fetchImpl = async () => {
-      throw new Error("network down");
-    };
-    await expect(
-      fetchPlatformIdentityIds(BASE_URL, "assistant-key"),
-    ).resolves.toBeNull();
-  });
-});
-
-describe("resolvePlatformAssistantId", () => {
-  const originalFetch = globalThis.fetch;
-  const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
-  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
-  let fetchImpl: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response> = async () =>
-    new Response("not found", { status: 404 });
-
-  beforeEach(() => {
-    fetchCalls.length = 0;
-    fetchImpl = async () => new Response("not found", { status: 404 });
-    globalThis.fetch = (async (
-      input: RequestInfo | URL,
-      init?: RequestInit,
-    ) => {
-      const url = typeof input === "string" ? input : input.toString();
-      fetchCalls.push({ url, init });
-      return fetchImpl(input, init);
-    }) as unknown as typeof fetch;
-    delete process.env.ASSISTANT_API_KEY;
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-    _resetPlatformIdentityEnsureForTests();
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    if (originalAssistantApiKeyEnv === undefined) {
-      delete process.env.ASSISTANT_API_KEY;
-    } else {
-      process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
-    }
-    setPlatformBaseUrl(undefined);
-    setPlatformAssistantId(undefined);
-    setPlatformOrganizationId(undefined);
-    setPlatformUserId(undefined);
-    _resetPlatformIdentityEnsureForTests();
-  });
-
-  test("returns the in-memory override without calling validate", async () => {
-    setPlatformAssistantId(ASSISTANT_ID);
-    process.env.ASSISTANT_API_KEY = "assistant-key";
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
-    expect(fetchCalls).toHaveLength(0);
-  });
-
-  test("returns empty when the in-memory override is unset and there is no API key", async () => {
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    expect(fetchCalls).toHaveLength(0);
-  });
-
-  test("loads ids from validate when the in-memory override is empty", async () => {
-    process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
-    expect(fetchCalls).toHaveLength(1);
-    expect(fetchCalls[0]?.url).toBe(
-      `${getPlatformBaseUrl().replace(/\/+$/, "")}${PLATFORM_IDENTITY_VALIDATE_PATH}`,
-    );
-  });
-
-  test("does not retry validate during the cooldown after a failure", async () => {
-    process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
-    fetchImpl = async () => new Response("down", { status: 503 });
-
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    expect(fetchCalls).toHaveLength(1);
-  });
-
-  test("retries validate after a failed attempt once the cooldown is cleared", async () => {
-    process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
-    fetchImpl = async () => new Response("down", { status: 503 });
-
-    await expect(resolvePlatformAssistantId()).resolves.toBe("");
-    _resetPlatformIdentityEnsureForTests();
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await expect(resolvePlatformAssistantId()).resolves.toBe(ASSISTANT_ID);
-    expect(fetchCalls).toHaveLength(2);
-  });
-
-  test("concurrent resolves share one in-flight validate", async () => {
-    process.env.ASSISTANT_API_KEY = "assistant-key";
-    setPlatformBaseUrl(BASE_URL);
-    let release!: (value: Response) => void;
-    let notifyFetchStarted!: () => void;
-    const fetchStarted = new Promise<void>((resolve) => {
-      notifyFetchStarted = resolve;
-    });
-    fetchImpl = () => {
-      notifyFetchStarted();
-      return new Promise<Response>((resolve) => {
-        release = resolve;
-      });
-    };
-
-    const first = resolvePlatformAssistantId();
-    const second = resolvePlatformAssistantId();
-    await fetchStarted;
-    expect(fetchCalls).toHaveLength(1);
-    release(
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      ),
-    );
-    await expect(first).resolves.toBe(ASSISTANT_ID);
-    await expect(second).resolves.toBe(ASSISTANT_ID);
-    expect(fetchCalls).toHaveLength(1);
-  });
-});

package/src/config/acp-agent-write.ts

@@ -1,43 +0,0 @@
-/**
- * Raw-config helper shared by the config PATCH and SET routes, the paths that
- * write a coding agent's entry.
- */
-
-import { isPlainObject } from "../util/object.js";
-
-/**
- * Clearing a leaf of a coding agent's entry is a write of `null` - a PATCH of
- * `{ acp: { agents: { <id>: { model: null } } } }` or a
- * `config set acp.agents.<id>.model null`. The deep-merge assigns that literal
- * `null` because the stored value is a scalar, and a SET writes it verbatim by
- * design. Both `command` and `model` are optional strings in `AcpConfigSchema`,
- * so a persisted `null` makes every later `loadConfig()` warn and take its
- * salvage path, dropping the whole `acp` section with the agents defined in it.
- * Clearing means removing the key, so drop it here on every write path.
- *
- * A cleared `command` then reads as an omitted one: a bundled id inherits the
- * profile's command, and an id that has no profile fails the agents refinement
- * with a message naming the id, which tells the user more than zod's "expected
- * string, received null".
- */
-export function scrubNulledAcpAgentLeaves(raw: Record<string, unknown>): void {
-  const acp = raw.acp;
-  if (!isPlainObject(acp)) {
-    return;
-  }
-  const agents = acp.agents;
-  if (!isPlainObject(agents)) {
-    return;
-  }
-  for (const entry of Object.values(agents)) {
-    if (!isPlainObject(entry)) {
-      continue;
-    }
-    if (entry.command === null) {
-      delete entry.command;
-    }
-    if (entry.model === null) {
-      delete entry.model;
-    }
-  }
-}

package/src/config/acp-schema.test.ts

@@ -1,81 +0,0 @@
-/**
- * Covers the ACP config leaf that carries model selection, the per-agent
- * `model`. It is optional with no `.default()`, so an absent value must stay
- * absent after parsing: the bundled profile supplies the model a session
- * starts on, and a key materialized as `undefined` would shadow it.
- *
- * `command` is optional in the same shape, so an entry for a bundled id can
- * carry a model and nothing else; the record's own check keeps a command
- * required for every id that has no bundled profile to inherit one from.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
-
-describe("AcpConfigSchema", () => {
-  test("populates defaults for an empty config", () => {
-    expect(AcpConfigSchema.parse({})).toEqual({
-      maxConcurrentSessions: 4,
-      agents: {},
-    });
-  });
-});
-
-describe("AcpConfigSchema agents", () => {
-  test("a bundled id's entry may omit command and name only a model", () => {
-    const parsed = AcpConfigSchema.parse({
-      agents: { claude: { model: "sonnet" } },
-    });
-
-    expect(parsed.agents).toEqual({ claude: { args: [], model: "sonnet" } });
-    expect("command" in parsed.agents.claude!).toBe(false);
-  });
-
-  test("an id with no bundled profile needs a command", () => {
-    const result = AcpConfigSchema.safeParse({
-      agents: { mine: { model: "sonnet" } },
-    });
-
-    expect(result.success).toBe(false);
-    if (result.success) {
-      return;
-    }
-    expect(result.error.issues.map((issue) => issue.path)).toEqual([
-      ["agents", "mine", "command"],
-    ]);
-    expect(result.error.issues[0]?.message).toContain("acp.agents.mine");
-  });
-
-  test("an id naming an Object.prototype member inherits no command", () => {
-    expect(
-      AcpConfigSchema.safeParse({ agents: { constructor: { model: "x" } } })
-        .success,
-    ).toBe(false);
-  });
-});
-
-describe("AcpAgentConfigSchema", () => {
-  test("round-trips a per-agent model override", () => {
-    expect(
-      AcpAgentConfigSchema.parse({
-        command: "claude-agent-acp",
-        model: "opus",
-      }),
-    ).toEqual({ command: "claude-agent-acp", args: [], model: "opus" });
-  });
-
-  test("leaves model unset when omitted, so a bundled profile's shows through", () => {
-    const parsed = AcpAgentConfigSchema.parse({ command: "claude-agent-acp" });
-
-    expect(parsed.model).toBeUndefined();
-    expect("model" in parsed).toBe(false);
-  });
-
-  test("rejects a non-string model", () => {
-    expect(
-      AcpAgentConfigSchema.safeParse({ command: "claude-agent-acp", model: 3 })
-        .success,
-    ).toBe(false);
-  });
-});

package/src/config/platform-identity.ts

@@ -1,201 +0,0 @@
-/**
- * Bound platform identity (assistant, organization, user).
- *
- * Django maps an assistant API key to these ids via
- * `POST /v1/internal/assistants/validate/`. Process startup rehydrates from
- * that endpoint into the in-memory overrides. Resolution reads those
- * overrides (and `PLATFORM_ORGANIZATION_ID` / `PLATFORM_USER_ID` when set).
- * When the in-memory assistant id is empty, the next resolve retries
- * validate (single-flight, with a cooldown after a failed attempt).
- */
-
-import { credentialKey } from "../security/credential-key.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
-import { getLogger } from "../util/logger.js";
-import {
-  getPlatformAssistantId,
-  getPlatformBaseUrl,
-  getPlatformOrganizationId,
-  getPlatformUserId,
-  setPlatformAssistantId,
-  setPlatformOrganizationId,
-  setPlatformUserId,
-} from "./env.js";
-
-const log = getLogger("platform-identity");
-
-export const PLATFORM_IDENTITY_VALIDATE_PATH =
-  "/v1/internal/assistants/validate/";
-
-const VALIDATE_TIMEOUT_MS = 5_000;
-const ENSURE_COOLDOWN_MS = 10_000;
-
-export type PlatformIdentityIds = {
-  assistantId: string;
-  organizationId: string;
-  userId: string;
-};
-
-function asNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-export function applyPlatformIdentityIds(ids: PlatformIdentityIds): void {
-  if (ids.assistantId) {
-    setPlatformAssistantId(ids.assistantId);
-  }
-  if (ids.organizationId) {
-    setPlatformOrganizationId(ids.organizationId);
-  }
-  if (ids.userId) {
-    setPlatformUserId(ids.userId);
-  }
-}
-
-/**
- * Trade an assistant API key for the bound platform ids.
- *
- * Returns null when the platform is unreachable, refuses the key, or the
- * body has no ids. Never throws.
- */
-export async function fetchPlatformIdentityIds(
-  baseUrl: string,
-  apiKey: string,
-): Promise<PlatformIdentityIds | null> {
-  const url = `${baseUrl.replace(/\/+$/, "")}${PLATFORM_IDENTITY_VALIDATE_PATH}`;
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Api-Key ${apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: "{}",
-      signal: AbortSignal.timeout(VALIDATE_TIMEOUT_MS),
-    });
-    if (!res.ok) {
-      log.warn(
-        { status: res.status },
-        "platform identity validate returned non-2xx",
-      );
-      return null;
-    }
-    const body: unknown = await res.json();
-    if (!body || typeof body !== "object") {
-      return null;
-    }
-    const obj = body as Record<string, unknown>;
-    const assistantId = asNonEmptyString(obj.assistant_id);
-    const organizationId = asNonEmptyString(obj.organization_id);
-    const userId = asNonEmptyString(obj.user_id);
-    if (!assistantId && !organizationId && !userId) {
-      return null;
-    }
-    return {
-      assistantId: assistantId ?? "",
-      organizationId: organizationId ?? "",
-      userId: userId ?? "",
-    };
-  } catch (err) {
-    log.warn({ err }, "platform identity validate failed");
-    return null;
-  }
-}
-
-async function readAssistantApiKey(): Promise<string> {
-  try {
-    const stored = (
-      await getSecureKeyAsync(credentialKey("vellum", "assistant_api_key"))
-    )?.trim();
-    if (stored) {
-      return stored;
-    }
-  } catch (err) {
-    log.warn({ err }, "failed to read assistant API key from credential store");
-  }
-  return process.env.ASSISTANT_API_KEY?.trim() ?? "";
-}
-
-let ensureInFlight: Promise<void> | null = null;
-let nextEnsureAttemptAt = 0;
-
-export function _resetPlatformIdentityEnsureForTests(): void {
-  ensureInFlight = null;
-  nextEnsureAttemptAt = 0;
-}
-
-/**
- * Load in-memory platform ids from validate when they are missing.
- *
- * No-ops when the assistant id is already set, when auth prerequisites are
- * missing, or when a failed attempt is still inside the cooldown window.
- * Concurrent callers share one in-flight request.
- */
-export async function ensurePlatformIdentityIds(): Promise<void> {
-  if (getPlatformAssistantId().trim()) {
-    return;
-  }
-  if (Date.now() < nextEnsureAttemptAt) {
-    return;
-  }
-  if (!ensureInFlight) {
-    ensureInFlight = (async () => {
-      try {
-        const apiKey = await readAssistantApiKey();
-        const baseUrl = getPlatformBaseUrl();
-        if (!apiKey || !baseUrl) {
-          return;
-        }
-        const ids = await fetchPlatformIdentityIds(baseUrl, apiKey);
-        if (!ids) {
-          nextEnsureAttemptAt = Date.now() + ENSURE_COOLDOWN_MS;
-          return;
-        }
-        applyPlatformIdentityIds(ids);
-        nextEnsureAttemptAt = 0;
-        log.info("Loaded platform identity from platform validate");
-      } finally {
-        ensureInFlight = null;
-      }
-    })();
-  }
-  await ensureInFlight;
-}
-
-export async function resolvePlatformAssistantId(): Promise<string> {
-  const existing = getPlatformAssistantId().trim();
-  if (existing) {
-    return existing;
-  }
-  await ensurePlatformIdentityIds();
-  return getPlatformAssistantId().trim();
-}
-
-export async function resolvePlatformAssistantIdOrNull(): Promise<
-  string | null
-> {
-  const id = await resolvePlatformAssistantId();
-  return id || null;
-}
-
-export async function resolvePlatformOrganizationId(): Promise<string> {
-  const existing = getPlatformOrganizationId().trim();
-  if (existing) {
-    return existing;
-  }
-  await ensurePlatformIdentityIds();
-  return getPlatformOrganizationId().trim();
-}
-
-export async function resolvePlatformUserId(): Promise<string> {
-  const existing = getPlatformUserId().trim();
-  if (existing) {
-    return existing;
-  }
-  await ensurePlatformIdentityIds();
-  return getPlatformUserId().trim();
-}