@vellumai/assistant 0.11.1-dev.202608042001.feb8dd6 → 0.11.1-dev.202608042130.2b7da8d

package/node_modules/@vellumai/environments/src/__tests__/install-layout.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for reading an install layout: telling a repo checkout from an
+ * installed package, and locating the `assistant` command that ships with an
+ * install.
+ */
+
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { findAssistantCommand, isRepoCheckoutPath } from "../index.js";
+
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "install-layout-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+/** Create `<nodeModulesDir>/.bin/assistant` and return its path. */
+function seedCommand(nodeModulesDir: string): string {
+  const binDir = join(nodeModulesDir, ".bin");
+  mkdirSync(binDir, { recursive: true });
+  const command = join(binDir, "assistant");
+  writeFileSync(command, "#!/usr/bin/env bun\n");
+  return command;
+}
+
+describe("isRepoCheckoutPath", () => {
+  test("an installed package is not a checkout", () => {
+    expect(
+      isRepoCheckoutPath(
+        "/Users/x/Library/Application Support/@vellumai/macos/cli/latest/node_modules/@vellumai/assistant/src/index.ts",
+      ),
+    ).toBe(false);
+  });
+
+  test("a repo checkout is", () => {
+    expect(
+      isRepoCheckoutPath("/Users/x/dev/vellum/assistant/src/index.ts"),
+    ).toBe(true);
+  });
+
+  test("a directory merely named node_modules-ish is not enough", () => {
+    expect(
+      isRepoCheckoutPath("/Users/x/node_modules_backup/a/src/index.ts"),
+    ).toBe(true);
+  });
+});
+
+describe("findAssistantCommand", () => {
+  test("finds the command shipped beside an installed package", () => {
+    const nodeModules = join(root, "cli", "latest", "node_modules");
+    const command = seedCommand(nodeModules);
+    const path = join(nodeModules, "@vellumai", "assistant", "src", "index.ts");
+
+    expect(findAssistantCommand(path)).toBe(command);
+  });
+
+  test("prefers a nested install over a hoisted one", () => {
+    const outer = join(root, "node_modules");
+    const outerCommand = seedCommand(outer);
+    const inner = join(outer, "vellum", "node_modules");
+    const innerCommand = seedCommand(inner);
+    const path = join(inner, "@vellumai", "assistant", "src", "index.ts");
+
+    expect(findAssistantCommand(path)).toBe(innerCommand);
+    expect(innerCommand).not.toBe(outerCommand);
+  });
+
+  test("falls back to a hoisted install when the nested one has no command", () => {
+    const outer = join(root, "node_modules");
+    const outerCommand = seedCommand(outer);
+    const inner = join(outer, "vellum", "node_modules");
+    mkdirSync(inner, { recursive: true });
+    const path = join(inner, "@vellumai", "assistant", "src", "index.ts");
+
+    expect(findAssistantCommand(path)).toBe(outerCommand);
+  });
+
+  test("returns null for a repo checkout", () => {
+    expect(
+      findAssistantCommand(join(root, "assistant", "src", "index.ts")),
+    ).toBeNull();
+  });
+
+  test("returns null when the install ships no assistant command", () => {
+    const nodeModules = join(root, "node_modules");
+    mkdirSync(join(nodeModules, ".bin"), { recursive: true });
+    const path = join(nodeModules, "@vellumai", "assistant", "src", "index.ts");
+
+    expect(findAssistantCommand(path)).toBeNull();
+  });
+});

package/node_modules/@vellumai/environments/src/__tests__/package-boundary.test.ts

@@ -1,10 +1,10 @@
 /**
  * Package boundary tests for @vellumai/environments.
  *
- * This package is the lowest layer of the shared-packages hierarchy: pure
- * environment types and constants with no runtime dependencies. It must
- * stay a leaf so any consumer (CLI, assistant, local-mode host) can depend
- * on it without dragging in a dependency tree.
+ * This package is the lowest layer of the shared-packages hierarchy:
+ * environment types, constants, and small helpers over node builtins, with no
+ * runtime dependencies. It must stay a leaf so any consumer (CLI, assistant,
+ * local-mode host) can depend on it without dragging in a dependency tree.
  *
  * Enforces that the package:
  * 1. Imports only node builtins and its own relative modules — no `@vellumai/*`
@@ -79,7 +79,7 @@ describe("package boundary", () => {
       throw new Error(
         `Found ${violations.length} forbidden import(s) in @vellumai/environments:\n` +
           violations.map((v) => `  - ${v}`).join("\n") +
-          "\n\n@vellumai/environments is a pure types/constants leaf and must\n" +
+          "\n\n@vellumai/environments is a dependency-free leaf and must\n" +
           "import only node builtins and its own relative modules.",
       );
     }

package/node_modules/@vellumai/environments/src/index.ts

@@ -1,11 +1,22 @@
 /**
- * @vellumai/environments — the single source of truth for Vellum's known
- * deployment environments (names, platform/web URLs, per-service port
- * blocks). Consumed by the CLI, the assistant daemon, and the local-mode
- * host library so the environment list is defined exactly once on the TS
- * side. The Swift client mirrors the same set in `VellumEnvironment.swift`.
+ * @vellumai/environments: the single source of truth for how a Vellum install
+ * is laid out and which deployment environment it belongs to.
  *
- * Intentionally free of runtime dependencies: pure types and constants only.
+ * Two things live here:
+ *
+ *   - The known deployment environments (names, platform/web URLs, per-service
+ *     port blocks). The Swift client mirrors the same set in
+ *     `VellumEnvironment.swift`.
+ *   - Install layout: whether a runtime is a repo checkout or an installed
+ *     package, and where the `assistant` command it ships lives.
+ *
+ * Consumed by the CLI, the assistant daemon, and the local-mode host library
+ * so each answer is defined exactly once on the TS side.
+ *
+ * This is the lowest layer of the shared-packages hierarchy and stays a leaf:
+ * types, constants, and small helpers over node builtins, with no runtime
+ * dependencies of its own. See `__tests__/package-boundary.test.ts`.
  */
 export * from "./types.js";
 export * from "./seeds.js";
+export * from "./install-layout.js";

package/node_modules/@vellumai/environments/src/install-layout.ts

@@ -0,0 +1,49 @@
+/**
+ * Reading the layout a Vellum runtime is installed in.
+ *
+ * The daemon is started either from a developer's repo checkout or from an
+ * installed npm package (`<install>/node_modules/@vellumai/assistant/src/
+ * index.ts`, which is what the desktop app runs). The CLI needs the layout to
+ * decide whether a launch is a dev run and what to put on the daemon's PATH;
+ * the daemon needs it to decide what to install as the `assistant` command.
+ * Both ask the same two questions, so they ask them here.
+ */
+
+import { existsSync } from "node:fs";
+import { join, sep } from "node:path";
+
+const NODE_MODULES_SEGMENT = `${sep}node_modules${sep}`;
+
+/**
+ * Whether `path` sits in a developer's repo checkout rather than inside an
+ * installed package.
+ */
+export function isRepoCheckoutPath(path: string): boolean {
+  return !path.includes(NODE_MODULES_SEGMENT);
+}
+
+/**
+ * The `assistant` command shipped with the install that contains `path`, or
+ * null when there is none (a repo checkout, or an install whose dependency
+ * graph omits the package declaring the bin).
+ *
+ * Searches innermost `node_modules` outward, since a nested install shadows a
+ * hoisted one.
+ */
+export function findAssistantCommand(path: string): string | null {
+  let index = path.lastIndexOf(NODE_MODULES_SEGMENT);
+
+  while (index !== -1) {
+    const nodeModulesDir = path.slice(
+      0,
+      index + NODE_MODULES_SEGMENT.length - 1,
+    );
+    const command = join(nodeModulesDir, ".bin", "assistant");
+    if (existsSync(command)) {
+      return command;
+    }
+    index = path.lastIndexOf(NODE_MODULES_SEGMENT, index - 1);
+  }
+
+  return null;
+}

package/openapi.yaml

@@ -19056,6 +19056,76 @@ paths:
                                   - requestId
                                   - entries
                                 additionalProperties: false
+                              answeredQuestion:
+                                type: object
+                                properties:
+                                  requestId:
+                                    type: string
+                                  questions:
+                                    type: array
+                                    items:
+                                      type: object
+                                      properties:
+                                        id:
+                                          type: string
+                                        question:
+                                          type: string
+                                        description:
+                                          type: string
+                                        options:
+                                          type: array
+                                          items:
+                                            type: object
+                                            properties:
+                                              id:
+                                                type: string
+                                              label:
+                                                type: string
+                                              description:
+                                                type: string
+                                            required:
+                                              - id
+                                              - label
+                                            additionalProperties: false
+                                        freeTextPlaceholder:
+                                          type: string
+                                      required:
+                                        - id
+                                        - question
+                                        - options
+                                      additionalProperties: false
+                                  responses:
+                                    type: array
+                                    items:
+                                      type: object
+                                      properties:
+                                        questionId:
+                                          type: string
+                                        decision:
+                                          type: string
+                                          enum:
+                                            - option
+                                            - free_text
+                                            - skipped
+                                        optionId:
+                                          type: string
+                                        text:
+                                          type: string
+                                      required:
+                                        - questionId
+                                        - decision
+                                      additionalProperties: false
+                                  overall:
+                                    type: string
+                                    enum:
+                                      - completed
+                                      - closed
+                                required:
+                                  - requestId
+                                  - questions
+                                  - responses
+                                  - overall
+                                additionalProperties: false
                             required:
                               - name
                               - input
@@ -19495,6 +19565,76 @@ paths:
                                           - requestId
                                           - entries
                                         additionalProperties: false
+                                      answeredQuestion:
+                                        type: object
+                                        properties:
+                                          requestId:
+                                            type: string
+                                          questions:
+                                            type: array
+                                            items:
+                                              type: object
+                                              properties:
+                                                id:
+                                                  type: string
+                                                question:
+                                                  type: string
+                                                description:
+                                                  type: string
+                                                options:
+                                                  type: array
+                                                  items:
+                                                    type: object
+                                                    properties:
+                                                      id:
+                                                        type: string
+                                                      label:
+                                                        type: string
+                                                      description:
+                                                        type: string
+                                                    required:
+                                                      - id
+                                                      - label
+                                                    additionalProperties: false
+                                                freeTextPlaceholder:
+                                                  type: string
+                                              required:
+                                                - id
+                                                - question
+                                                - options
+                                              additionalProperties: false
+                                          responses:
+                                            type: array
+                                            items:
+                                              type: object
+                                              properties:
+                                                questionId:
+                                                  type: string
+                                                decision:
+                                                  type: string
+                                                  enum:
+                                                    - option
+                                                    - free_text
+                                                    - skipped
+                                                optionId:
+                                                  type: string
+                                                text:
+                                                  type: string
+                                              required:
+                                                - questionId
+                                                - decision
+                                              additionalProperties: false
+                                          overall:
+                                            type: string
+                                            enum:
+                                              - completed
+                                              - closed
+                                        required:
+                                          - requestId
+                                          - questions
+                                          - responses
+                                          - overall
+                                        additionalProperties: false
                                     required:
                                       - name
                                       - input
@@ -33307,14 +33447,6 @@ components:
                 anyOf:
                   - $ref: "#/components/schemas/CallSiteOverrideDraft"
                   - type: "null"
-            defaultProfileOverrides:
-              type: object
-              propertyNames:
-                type: string
-              additionalProperties:
-                anyOf:
-                  - type: string
-                  - type: "null"
             profileSession:
               anyOf:
                 - type: object
@@ -34142,12 +34274,6 @@ components:
                         type: string
                     additionalProperties: false
                   - type: "null"
-            defaultProfileOverrides:
-              type: object
-              propertyNames:
-                type: string
-              additionalProperties:
-                type: string
             profileSession:
               type: object
               properties:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608042001.feb8dd6",
+  "version": "0.11.1-dev.202608042130.2b7da8d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-image-optimize.test.ts

@@ -115,9 +115,9 @@ describe("upscaleTargetDimensions", () => {
 });
 
 describe("upscaleImageToMinimum", () => {
-  it("returns null when dimensions are unparseable", () => {
+  it("returns null when dimensions are unparseable", async () => {
     expect(
-      upscaleImageToMinimum(
+      await upscaleImageToMinimum(
         Buffer.from("not an image").toString("base64"),
         "image/png",
       ),
@@ -126,12 +126,12 @@ describe("upscaleImageToMinimum", () => {
 });
 
 describe("optimizeImageForTransport", () => {
-  it("passes an undersized image through unchanged — the minimum floor is rejection-path only", () => {
+  it("passes an undersized image through unchanged: the minimum floor is rejection-path only", async () => {
     // The floor is undocumented provider behavior, so pre-send transport
     // never enforces it; only the image-recovery plugin reacts to an actual
     // "Could not process image" rejection.
     const tiny = makePngBase64(16, 14);
-    expect(optimizeImageForTransport(tiny, "image/png")).toEqual({
+    expect(await optimizeImageForTransport(tiny, "image/png")).toEqual({
       data: tiny,
       mediaType: "image/png",
     });

package/src/__tests__/agent-loop-subagent-billing-headers.test.ts

@@ -0,0 +1,166 @@
+/**
+ * The runtime proxy bills delegated work off `X-Vellum-Subagent-Role` and
+ * `X-Vellum-Subagent-Spawn-Mode`. `RetryProvider` resolves both from
+ * `config.conversationId`, so the headers only ever materialize in production
+ * if `AgentLoop` stamps its own conversation id onto the provider config it
+ * sends. These tests drive a real `AgentLoop` through a real `RetryProvider`
+ * so a config field dropped at the loop can never pass silently.
+ *
+ * Subagents run their turns through `ConversationRunner.runAgentLoop` with
+ * `callSite: "subagentSpawn"`, which is the shape reproduced here.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { AgentLoop } from "../agent/loop.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { rawRun } from "../persistence/raw-query.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import { resetSubagentAttributionCacheForTests } from "../usage/subagent-attribution.js";
+import { setConfig } from "./helpers/set-config.js";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+/**
+ * Stands in for the transport underneath `RetryProvider`, recording the config
+ * it is handed. That config is what would go on the wire, so it is also where
+ * the resolved billing headers land.
+ */
+function makeRecordingProvider(name: string): {
+  provider: Provider;
+  configs: () => Array<Record<string, unknown>>;
+} {
+  const configs: Array<Record<string, unknown>> = [];
+  const provider: Provider = {
+    name,
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      configs.push((options?.config ?? {}) as Record<string, unknown>);
+      return {
+        content: [{ type: "text", text: "ok" }],
+        model: "gpt-sub",
+        usage: { inputTokens: 1, outputTokens: 1 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, configs: () => configs };
+}
+
+async function seedConversation(
+  id: string,
+  subagentRole: string | null,
+  subagentSpawnMode: string | null,
+): Promise<void> {
+  await initializeDb();
+  resetSubagentAttributionCacheForTests();
+  rawRun(
+    "test:seedSubagentConversation",
+    `INSERT OR REPLACE INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode)
+     VALUES (?, 'background', 1000, 1000, ?, ?)`,
+    id,
+    subagentRole,
+    subagentSpawnMode,
+  );
+}
+
+/** Runs one loop turn the way a subagent's conversation runner does. */
+async function runSubagentTurn(
+  provider: Provider,
+  conversationId: string,
+): Promise<void> {
+  const loop = new AgentLoop({
+    provider,
+    systemPrompt: "system",
+    conversationId,
+    config: { maxTokens: 1024 },
+  });
+  await loop.run({
+    requestId: "test-request",
+    messages: [userMessage],
+    onEvent: () => {},
+    trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    callSite: "subagentSpawn",
+  });
+}
+
+describe("AgentLoop subagent billing-header attribution", () => {
+  beforeEach(() => {
+    setConfig("llm", {
+      callSites: { subagentSpawn: { provider: "openai", model: "gpt-sub" } },
+    });
+  });
+
+  test("forwards the spawning role and mode on a subagent conversation's turn", async () => {
+    // GIVEN a conversation stamped as an advisor-consult subagent
+    await seedConversation("conv-loop-advisor", "advisor", "advisor_consult");
+
+    // AND a managed-proxy-shaped provider stack (headers forwarded)
+    const { provider, configs } = makeRecordingProvider("openai");
+    const wrapped = new RetryProvider(provider, {
+      forwardUsageAttributionHeaders: true,
+    });
+
+    // WHEN that subagent's loop runs a turn
+    await runSubagentTurn(wrapped, "conv-loop-advisor");
+
+    // THEN the transport sees the delegated-work attribution
+    expect(configs()).toHaveLength(1);
+    const headers = configs()[0]?.usageAttributionHeaders as Record<
+      string,
+      string
+    >;
+    expect(headers["X-Vellum-Subagent-Role"]).toBe("advisor");
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBe("advisor_consult");
+    expect(headers["X-Vellum-LLM-Call-Site"]).toBe("subagentSpawn");
+
+    // AND the routing-time id itself never reaches the wire config
+    expect(configs()[0]?.conversationId).toBeUndefined();
+  });
+
+  test("omits the subagent headers on a turn for a plain conversation", async () => {
+    // GIVEN a conversation that was not spawned as a subagent
+    await seedConversation("conv-loop-plain", null, null);
+
+    const { provider, configs } = makeRecordingProvider("openai");
+    const wrapped = new RetryProvider(provider, {
+      forwardUsageAttributionHeaders: true,
+    });
+
+    // WHEN its loop runs a turn
+    await runSubagentTurn(wrapped, "conv-loop-plain");
+
+    // THEN the base attribution is present without the delegated-work fields
+    const headers = configs()[0]?.usageAttributionHeaders as Record<
+      string,
+      string
+    >;
+    expect(headers["X-Vellum-LLM-Call-Site"]).toBe("subagentSpawn");
+    expect(headers["X-Vellum-Subagent-Role"]).toBeUndefined();
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBeUndefined();
+  });
+
+  test("stamps the conversation id on the provider config it sends", async () => {
+    // GIVEN a bare recording provider (no `RetryProvider` to consume the field)
+    const { provider, configs } = makeRecordingProvider("openai");
+
+    // WHEN a loop with a conversation id runs a call-site turn
+    await runSubagentTurn(provider, "conv-loop-raw");
+
+    // THEN the id the header lookup depends on is on the config, alongside the
+    // mix-expansion seed
+    expect(configs()[0]?.conversationId).toBe("conv-loop-raw");
+    expect(configs()[0]?.selectionSeed).toBe("conv-loop-raw");
+  });
+});