@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/providers/vellum/client.ts

@@ -1,4 +1,7 @@
+import { getWorkspaceDir } from "../../util/platform.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import type { SendMessageOptions } from "../types.js";
+import { hostedDirectionsExtraBody } from "./personality-directions.js";
 
 export interface VellumProviderOptions {
   apiKey?: string;
@@ -7,7 +10,7 @@ export interface VellumProviderOptions {
 }
 
 /**
- * OpenAI-compatible client for Vellum-hosted GPU inference (vLLM).
+ * OpenAI-compatible client for Vellum-hosted GPU inference.
  * Managed requests set `baseURL` to the platform `/v1/runtime-proxy/vellum`
  * path and authenticate with the assistant API key. These models have no
  * bring-your-own-key path.
@@ -26,4 +29,14 @@ export class VellumProvider extends OpenAIChatCompletionsProvider {
       ...(options.baseURL ? { baseURL: options.baseURL } : {}),
     });
   }
+
+  protected override buildRequestExtraBody(
+    options?: SendMessageOptions,
+  ): Record<string, unknown> | undefined {
+    const config = options?.config as { model?: string } | undefined;
+    return hostedDirectionsExtraBody(
+      config?.model ?? this.defaultModel,
+      getWorkspaceDir(),
+    );
+  }
 }

package/src/providers/vellum/personality-directions.test.ts

@@ -0,0 +1,163 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import {
+  HOSTED_STEERING_MODEL,
+  hostedDirectionsExtraBody,
+  mapPersonalitySlidersToDirections,
+  parsePersonalitySliderSidecar,
+  PERSONALITY_SLIDERS_PATH,
+  readPersonalitySliderSidecar,
+  resolveHostedDirections,
+} from "./personality-directions.js";
+
+function sliders(overrides: Record<string, number>): Record<string, number> {
+  return {
+    "companion-coworker": 50,
+    "genz-boomer": 50,
+    "execute-collaborate": 50,
+    "playful-serious": 50,
+    "polite-unfiltered": 50,
+    ...overrides,
+  };
+}
+
+describe("mapPersonalitySlidersToDirections", () => {
+  test("center and omitted values produce no directions", () => {
+    expect(mapPersonalitySlidersToDirections(undefined)).toBeUndefined();
+    expect(mapPersonalitySlidersToDirections(null)).toBeUndefined();
+    expect(mapPersonalitySlidersToDirections(sliders({}))).toBeUndefined();
+    expect(
+      mapPersonalitySlidersToDirections(sliders({ "companion-coworker": 50 })),
+    ).toBeUndefined();
+  });
+
+  test("maps 0 / 25 / 75 / 100 onto one-sided alphas", () => {
+    expect(
+      mapPersonalitySlidersToDirections(sliders({ "companion-coworker": 0 })),
+    ).toEqual({ companion: 1 });
+    expect(
+      mapPersonalitySlidersToDirections(sliders({ "companion-coworker": 25 })),
+    ).toEqual({ companion: 0.5 });
+    expect(
+      mapPersonalitySlidersToDirections(sliders({ "companion-coworker": 75 })),
+    ).toEqual({ coworker: 0.5 });
+    expect(
+      mapPersonalitySlidersToDirections(sliders({ "companion-coworker": 100 })),
+    ).toEqual({ coworker: 1 });
+  });
+
+  test("maps each axis onto its left or right pole", () => {
+    expect(
+      mapPersonalitySlidersToDirections(
+        sliders({
+          "companion-coworker": 0,
+          "genz-boomer": 100,
+          "execute-collaborate": 25,
+          "playful-serious": 75,
+          "polite-unfiltered": 0,
+        }),
+      ),
+    ).toEqual({
+      companion: 1,
+      boomer: 1,
+      independent: 0.5,
+      serious: 0.5,
+      polite: 1,
+    });
+  });
+
+  test("clamps out-of-range sliders and ignores non-finite values", () => {
+    expect(
+      mapPersonalitySlidersToDirections(
+        sliders({
+          "companion-coworker": -20,
+          "genz-boomer": 140,
+          "playful-serious": Number.NaN,
+        }),
+      ),
+    ).toEqual({ companion: 1, boomer: 1 });
+  });
+
+  test("ignores unknown slider ids", () => {
+    expect(
+      mapPersonalitySlidersToDirections(
+        sliders({ "not-an-axis": 0, "companion-coworker": 25 }),
+      ),
+    ).toEqual({ companion: 0.5 });
+  });
+});
+
+describe("resolveHostedDirections", () => {
+  test("attaches directions only for the hosted Qwen snapshot", () => {
+    const values = sliders({ "companion-coworker": 0 });
+    expect(
+      resolveHostedDirections({
+        model: HOSTED_STEERING_MODEL,
+        sliders: values,
+      }),
+    ).toEqual({ companion: 1 });
+    expect(
+      resolveHostedDirections({
+        model: "claude-opus-4-8",
+        sliders: values,
+      }),
+    ).toBeUndefined();
+    expect(
+      resolveHostedDirections({
+        model: HOSTED_STEERING_MODEL,
+        sliders: sliders({}),
+      }),
+    ).toBeUndefined();
+  });
+});
+
+describe("personality slider sidecar", () => {
+  test("parses a valid sidecar and rejects malformed payloads", () => {
+    expect(
+      parsePersonalitySliderSidecar(
+        JSON.stringify({ "companion-coworker": 25, extra: "nope" }),
+      ),
+    ).toEqual({ "companion-coworker": 25 });
+    expect(parsePersonalitySliderSidecar("not-json")).toBeNull();
+    expect(parsePersonalitySliderSidecar("[]")).toBeNull();
+  });
+
+  test("reads data/personality-sliders.json from the workspace", () => {
+    const workspace = mkdtempSync(join(tmpdir(), "personality-sliders-"));
+    mkdirSync(join(workspace, "data"));
+    writeFileSync(
+      join(workspace, PERSONALITY_SLIDERS_PATH),
+      JSON.stringify({ "companion-coworker": 0 }),
+    );
+    expect(readPersonalitySliderSidecar(workspace)).toEqual({
+      "companion-coworker": 0,
+    });
+    expect(readPersonalitySliderSidecar(join(workspace, "missing"))).toBeNull();
+  });
+
+  test("builds extraBody only for hosted Qwen with a nonzero sidecar", () => {
+    const workspace = mkdtempSync(join(tmpdir(), "personality-extra-body-"));
+    mkdirSync(join(workspace, "data"));
+    writeFileSync(
+      join(workspace, PERSONALITY_SLIDERS_PATH),
+      JSON.stringify({ "companion-coworker": 25 }),
+    );
+    expect(hostedDirectionsExtraBody(HOSTED_STEERING_MODEL, workspace)).toEqual(
+      {
+        directions: { companion: 0.5 },
+      },
+    );
+    expect(
+      hostedDirectionsExtraBody("claude-opus-4-8", workspace),
+    ).toBeUndefined();
+    expect(
+      hostedDirectionsExtraBody(
+        HOSTED_STEERING_MODEL,
+        join(workspace, "missing"),
+      ),
+    ).toBeUndefined();
+  });
+});

package/src/providers/vellum/personality-directions.ts

@@ -0,0 +1,120 @@
+/**
+ * Map persisted personality sliders onto hosted-inference direction alphas.
+ *
+ * Sliders are one-sided around center: 50 is no steer. Values below 50
+ * activate the left pole; values above 50 activate the right pole. The
+ * GPU server never sees slider ids, only `{ pole: alpha }` in `(0, 1]`.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  PERSONALITY_DIRECTION_AXES,
+  PERSONALITY_SLIDERS_PATH,
+} from "../../api/constants/personality-sliders.js";
+
+export {
+  PERSONALITY_DIRECTION_AXES,
+  PERSONALITY_SLIDERS_PATH,
+} from "../../api/constants/personality-sliders.js";
+
+export const HOSTED_STEERING_MODEL = "qwen/qwen3-8b";
+
+export type PersonalityDirections = Record<string, number>;
+
+export function isHostedSteeringModel(model: string): boolean {
+  return model === HOSTED_STEERING_MODEL;
+}
+
+function clampSlider(value: number): number {
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 100) {
+    return 100;
+  }
+  return value;
+}
+
+export function mapPersonalitySlidersToDirections(
+  values: Record<string, number> | null | undefined,
+): PersonalityDirections | undefined {
+  if (!values) {
+    return undefined;
+  }
+  const directions: PersonalityDirections = {};
+  for (const axis of PERSONALITY_DIRECTION_AXES) {
+    const raw = values[axis.sliderId];
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+      continue;
+    }
+    const slider = clampSlider(raw);
+    if (slider < 50) {
+      directions[axis.left] = (50 - slider) / 50;
+    } else if (slider > 50) {
+      directions[axis.right] = (slider - 50) / 50;
+    }
+  }
+  if (Object.keys(directions).length === 0) {
+    return undefined;
+  }
+  return directions;
+}
+
+export function parsePersonalitySliderSidecar(
+  raw: string,
+): Record<string, number> | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const values: Record<string, number> = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      values[key] = value;
+    }
+  }
+  return values;
+}
+
+export function readPersonalitySliderSidecar(
+  workspaceDir: string,
+): Record<string, number> | null {
+  try {
+    return parsePersonalitySliderSidecar(
+      readFileSync(join(workspaceDir, PERSONALITY_SLIDERS_PATH), "utf-8"),
+    );
+  } catch {
+    return null;
+  }
+}
+
+export function resolveHostedDirections(args: {
+  model: string;
+  sliders: Record<string, number> | null | undefined;
+}): PersonalityDirections | undefined {
+  if (!isHostedSteeringModel(args.model)) {
+    return undefined;
+  }
+  return mapPersonalitySlidersToDirections(args.sliders);
+}
+
+export function hostedDirectionsExtraBody(
+  model: string,
+  workspaceDir: string,
+): Record<string, unknown> | undefined {
+  const directions = resolveHostedDirections({
+    model,
+    sliders: readPersonalitySliderSidecar(workspaceDir),
+  });
+  if (!directions) {
+    return undefined;
+  }
+  return { directions };
+}

package/src/providers/xml-tool-call-salvage.ts

@@ -0,0 +1,212 @@
+/**
+ * Salvage Anthropic-style XML tool calls that some OpenAI-compatible models
+ * emit as assistant text instead of native `tool_calls`.
+ *
+ * Off by default. DeepSeek model ids enable it because those models are
+ * trained to emit DSML `invoke` markup and OpenAI-compatible hosts sometimes
+ * leave a prefix-stripped variant in `content`. Invokes inside markdown
+ * fences stay as text.
+ */
+
+import { indexOfTag, partialTagSuffix } from "../util/think-tag-stream.js";
+
+/** Openers a streaming scanner holds back so XML tool calls are not shown as text. */
+export const XML_TOOL_CALL_OPEN_TAGS = [
+  "<invoke",
+  "<function_calls",
+  "<minimax:tool_call",
+] as const;
+
+export interface SalvagedXmlToolCall {
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface XmlToolCallSalvage {
+  /** Assistant text with salvaged invoke blocks removed. */
+  text: string;
+  calls: SalvagedXmlToolCall[];
+}
+
+const INVOKE_CLOSE = "</invoke>";
+const NAME_ATTR_RE = /\bname\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i;
+const PARAMETER_CLOSE = "</parameter>";
+
+const EMPTY_WRAPPER_RE =
+  /<(?:function_calls|minimax:tool_call)>\s*<\/(?:function_calls|minimax:tool_call)>/gi;
+
+/** True when the model id is a DeepSeek variant that leaks XML tool calls. */
+export function shouldSalvageXmlToolCalls(
+  model: string | null | undefined,
+): boolean {
+  return typeof model === "string" && /deepseek/i.test(model);
+}
+
+export function salvageXmlToolCalls(
+  text: string,
+  offeredToolNames: ReadonlySet<string>,
+): XmlToolCallSalvage | null {
+  if (!text || offeredToolNames.size === 0) {
+    return null;
+  }
+
+  const spans: Array<{
+    start: number;
+    end: number;
+    call: SalvagedXmlToolCall;
+  }> = [];
+
+  const invokeOpenRe = /<invoke\b[^>]*>/gi;
+  let openMatch: RegExpExecArray | null = invokeOpenRe.exec(text);
+  while (openMatch) {
+    const openTag = openMatch[0];
+    const rawName = parseNameAttr(openTag);
+    const bodyStart = openMatch.index + openTag.length;
+    const closeIdx = text.indexOf(INVOKE_CLOSE, bodyStart);
+    if (closeIdx < 0) {
+      break;
+    }
+
+    const canonicalName = rawName
+      ? resolveOfferedName(rawName, offeredToolNames)
+      : null;
+    if (canonicalName && !isInsideMarkdownFence(text, openMatch.index)) {
+      spans.push({
+        start: openMatch.index,
+        end: closeIdx + INVOKE_CLOSE.length,
+        call: {
+          name: canonicalName,
+          input: parseParameters(text.slice(bodyStart, closeIdx)),
+        },
+      });
+    }
+
+    invokeOpenRe.lastIndex = closeIdx + INVOKE_CLOSE.length;
+    openMatch = invokeOpenRe.exec(text);
+  }
+
+  if (spans.length === 0) {
+    return null;
+  }
+
+  let leftover = "";
+  let cursor = 0;
+  for (const span of spans) {
+    leftover += text.slice(cursor, span.start);
+    cursor = span.end;
+  }
+  leftover += text.slice(cursor);
+  leftover = leftover.replace(EMPTY_WRAPPER_RE, "").trim();
+
+  return {
+    text: leftover,
+    calls: spans.map((span) => span.call),
+  };
+}
+
+/**
+ * Split streamed text so a complete or in-progress XML tool-call opener is
+ * held back rather than shown as user-visible content.
+ */
+export function splitXmlToolCallHoldback(buffer: string): {
+  visible: string;
+  held: string;
+} {
+  if (!buffer) {
+    return { visible: "", held: "" };
+  }
+  const hit = indexOfTag(buffer, XML_TOOL_CALL_OPEN_TAGS, false);
+  if (hit) {
+    return {
+      visible: buffer.slice(0, hit.index),
+      held: buffer.slice(hit.index),
+    };
+  }
+  const partial = partialTagSuffix(buffer, XML_TOOL_CALL_OPEN_TAGS, false);
+  if (partial > 0) {
+    return {
+      visible: buffer.slice(0, buffer.length - partial),
+      held: buffer.slice(buffer.length - partial),
+    };
+  }
+  return { visible: buffer, held: "" };
+}
+
+function parseNameAttr(tag: string): string | null {
+  const match = NAME_ATTR_RE.exec(tag);
+  if (!match) {
+    return null;
+  }
+  const name = match[1] ?? match[2] ?? match[3];
+  return name && name.length > 0 ? name : null;
+}
+
+function resolveOfferedName(
+  name: string,
+  offeredToolNames: ReadonlySet<string>,
+): string | null {
+  if (offeredToolNames.has(name)) {
+    return name;
+  }
+  const lower = name.toLowerCase();
+  for (const offered of offeredToolNames) {
+    if (offered.toLowerCase() === lower) {
+      return offered;
+    }
+  }
+  return null;
+}
+
+function parseParameters(body: string): Record<string, unknown> {
+  const input: Record<string, unknown> = {};
+  const parameterOpenRe = /<parameter\b[^>]*>/gi;
+  let paramMatch: RegExpExecArray | null = parameterOpenRe.exec(body);
+  while (paramMatch) {
+    const openTag = paramMatch[0];
+    const paramName = parseNameAttr(openTag);
+    const valueStart = paramMatch.index + openTag.length;
+    const closeIdx = body.indexOf(PARAMETER_CLOSE, valueStart);
+    if (closeIdx < 0) {
+      break;
+    }
+    if (paramName) {
+      input[paramName] = parseParamValue(
+        decodeXmlEntities(body.slice(valueStart, closeIdx)),
+      );
+    }
+    parameterOpenRe.lastIndex = closeIdx + PARAMETER_CLOSE.length;
+    paramMatch = parameterOpenRe.exec(body);
+  }
+  return input;
+}
+
+function parseParamValue(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}
+
+function isInsideMarkdownFence(text: string, index: number): boolean {
+  let inside = false;
+  let searchFrom = 0;
+  while (searchFrom < index) {
+    const next = text.indexOf("```", searchFrom);
+    if (next < 0 || next >= index) {
+      break;
+    }
+    inside = !inside;
+    searchFrom = next + 3;
+  }
+  return inside;
+}

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -490,7 +490,7 @@ describe("runBackgroundJob", () => {
     expect(bootstrapLastArgs).not.toHaveProperty("scheduleJobId");
   });
 
-  test("assistantSandwich seeds three messages in user/assistant/user order, with sandwich written before processMessage runs", async () => {
+  test("empty sandwich prompt uses the postamble as the processMessage kickoff", async () => {
     let addMessageCountAtProcessMessageStart = -1;
     processMessageImpl = async () => {
       addMessageCountAtProcessMessageStart = addMessageCalls.length;
@@ -508,7 +508,46 @@ describe("runBackgroundJob", () => {
       }),
     );
 
-    // All three sandwich addMessage calls happened.
+    // persistUserMessage rejects empty content, so the trusted postamble is
+    // the kickoff rather than a third addMessage plus an empty prompt.
+    expect(addMessageCalls).toHaveLength(2);
+    expect(addMessageCalls[0]).toMatchObject({
+      conversationId: STUB_CONVERSATION_ID,
+      role: "user",
+      content: "TRUSTED_PRE",
+    });
+    expect(addMessageCalls[1]).toMatchObject({
+      conversationId: STUB_CONVERSATION_ID,
+      role: "assistant",
+      content: "UNTRUSTED_PAYLOAD",
+    });
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].content).toBe("TRUSTED_POST");
+    expect(processMessageCalls[0].options).toMatchObject({
+      skipUserMessageIndexing: true,
+    });
+    expect(addMessageCountAtProcessMessageStart).toBe(2);
+    expect(emitCalls).toHaveLength(0);
+  });
+
+  test("non-empty sandwich prompt still seeds all three sandwich messages before processMessage", async () => {
+    let addMessageCountAtProcessMessageStart = -1;
+    processMessageImpl = async () => {
+      addMessageCountAtProcessMessageStart = addMessageCalls.length;
+      return { messageId: "msg-final" };
+    };
+
+    await runBackgroundJob(
+      baseOpts({
+        prompt: "do the test",
+        assistantSandwich: {
+          preamble: "TRUSTED_PRE",
+          content: "UNTRUSTED_PAYLOAD",
+          postamble: "TRUSTED_POST",
+        },
+      }),
+    );
+
     expect(addMessageCalls).toHaveLength(3);
     expect(addMessageCalls[0]).toMatchObject({
       conversationId: STUB_CONVERSATION_ID,
@@ -526,8 +565,7 @@ describe("runBackgroundJob", () => {
       content: "TRUSTED_POST",
     });
     expect(processMessageCalls).toHaveLength(1);
-    expect(processMessageCalls[0].content).toBe("");
-    // processMessage observed all 3 sandwich messages already in place.
+    expect(processMessageCalls[0].content).toBe("do the test");
     expect(addMessageCountAtProcessMessageStart).toBe(3);
   });
 

package/src/runtime/auth/__tests__/guard-tests.test.ts

@@ -72,9 +72,7 @@ describe("route policy coverage", () => {
     // registry had no entry for these endpoints, so `enforcePolicy`
     // returned allowed). Migration preserves behavior. Triage these
     // and assign real policies in a follow-up PR:
-    //   - PATCH/DELETE documents/:id/comments/:commentId
-    //   - integrations/a2a/{config,invite/accept}
-    //   - integrations/vercel/config
+    //   - integrations/a2a/invite/accept
     const INTENTIONALLY_UNPROTECTED = new Set([
       // A — design-intentional
       "health",
@@ -90,10 +88,7 @@ describe("route policy coverage", () => {
       "playground/seeded-conversations",
       "playground/seeded-conversations/:id",
       // C — pre-existing latent unprotected (follow-up audit owed)
-      "documents/:id/comments/:commentId",
-      "integrations/a2a/config",
       "integrations/a2a/invite/accept",
-      "integrations/vercel/config",
     ]);
 
     const unprotectedFound: string[] = [];

package/src/runtime/auth/__tests__/route-policy.test.ts

@@ -297,4 +297,69 @@ describe("ROUTES policy declarations", () => {
       expect(r.policy === null || typeof r.policy === "object").toBe(true);
     }
   });
+
+  test.each([
+    ["integrations_vercel_config_get", "settings.read"],
+    ["integrations_vercel_config_post", "settings.write"],
+    ["integrations_vercel_config_delete", "settings.write"],
+    ["integrations_a2a_config_get", "settings.read"],
+    ["integrations_a2a_config_post", "settings.write"],
+    ["integrations_a2a_config_delete", "settings.write"],
+  ] as const)(
+    "%s requires %s and actor principals",
+    async (operationId, scope) => {
+      const { ROUTES } = await import("../../routes/index.js");
+      const route = ROUTES.find((r) => r.operationId === operationId);
+      expect(route).toBeDefined();
+      expect(route!.policy).not.toBeNull();
+      expect(route!.policy!.requiredScopes).toEqual([scope]);
+      expect(route!.policy!.allowedPrincipalTypes).toEqual([
+        "actor",
+        "svc_gateway",
+        "svc_daemon",
+        "local",
+      ]);
+    },
+  );
+
+  test("vercel config GET denies a chat-only actor and POST denies without settings.write", async () => {
+    const { ROUTES } = await import("../../routes/index.js");
+    const getRoute = ROUTES.find(
+      (r) => r.operationId === "integrations_vercel_config_get",
+    );
+    const postRoute = ROUTES.find(
+      (r) => r.operationId === "integrations_vercel_config_post",
+    );
+    expect(getRoute?.policy).not.toBeNull();
+    expect(postRoute?.policy).not.toBeNull();
+
+    authDisabled = false;
+    const chatOnly = buildTestContext({
+      principalType: "actor",
+      scopes: ["chat.read", "chat.write"],
+    });
+    const getDenied = enforcePolicy(
+      getRoute!.endpoint,
+      getRoute!.policy!,
+      chatOnly,
+    );
+    expect(getDenied).not.toBeNull();
+    expect(getDenied!.status).toBe(403);
+
+    const postDenied = enforcePolicy(
+      postRoute!.endpoint,
+      postRoute!.policy!,
+      chatOnly,
+    );
+    expect(postDenied).not.toBeNull();
+    expect(postDenied!.status).toBe(403);
+
+    const settingsActor = buildTestContext({
+      principalType: "actor",
+      scopes: ["settings.write"],
+    });
+    expect(
+      enforcePolicy(postRoute!.endpoint, postRoute!.policy!, settingsActor),
+    ).toBeNull();
+  });
 });