@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/runtime/routes/__tests__/acp-routes.test.ts

@@ -11,7 +11,8 @@
  * silently auto-installs allowlisted adapter packages via a sandboxed `bun`
  * global install before failing with the install hint. `execFile` is stubbed
  * via the shared `installExecFileStub` helper so tests can script
- * `bun add --global` outcomes.
+ * `bun add --global` outcomes. It also threads the optional `model` through to
+ * the session manager and relays the warning a refused model comes back with.
  */
 
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -43,6 +44,10 @@ interface FakeSessionState {
   completedAt?: number;
   error?: string;
   stopReason?: string;
+  model?: string;
+  availableModels?: Array<{ value: string; label: string }>;
+  modelRevisionEpoch?: string;
+  modelRevision?: number;
   latestUsage?: {
     usedTokens: number;
     contextSize: number;
@@ -55,10 +60,27 @@ interface FakeSessionState {
 
 let fakeInMemorySessions: FakeSessionState[] = [];
 
-const spawnMock = mock(async () => ({
+interface SpawnResult {
+  acpSessionId: string;
+  protocolSessionId: string;
+  requestedModel?: string;
+  effectiveModel?: string;
+  modelWarning?: string;
+}
+
+const DEFAULT_SPAWN_RESULT: SpawnResult = {
   acpSessionId: "acp-route-session",
   protocolSessionId: "proto-route-session",
-}));
+  effectiveModel: "opus",
+};
+let spawnResult: SpawnResult = DEFAULT_SPAWN_RESULT;
+const spawnMock = mock(async (...args: unknown[]) => {
+  const options = args[6] as { model?: string } | undefined;
+  return {
+    ...spawnResult,
+    requestedModel: options?.model?.trim() || undefined,
+  };
+});
 
 const defaultSteerOrResumeImpl = async (
   _id: string,
@@ -182,6 +204,10 @@ interface ResponseShape {
     outputTokens?: number;
     eventLog?: unknown[];
     authErrorCode?: string;
+    model?: string;
+    availableModels?: Array<{ value: string; label: string }>;
+    modelRevisionEpoch?: string;
+    modelRevision?: number;
   }>;
 }
 
@@ -190,6 +216,7 @@ beforeEach(() => {
   clearHistory();
   resetExecFileStub();
   spawnMock.mockClear();
+  spawnResult = DEFAULT_SPAWN_RESULT;
   steerOrResumeMock.mockClear();
   steerOrResumeImpl = defaultSteerOrResumeImpl;
   _resetAdapterInstallCacheForTests();
@@ -328,6 +355,60 @@ describe("GET /v1/acp/sessions — merged in-memory + history", () => {
     expect(s!.outputTokens).toBeUndefined();
   });
 
+  test("carries the model for both layers and the picker for live ones only", async () => {
+    fakeInMemorySessions = [
+      {
+        id: "live-model",
+        agentId: "agent-live",
+        acpSessionId: "proto-live",
+        parentConversationId: "conv-model",
+        status: "running",
+        startedAt: 9000,
+        model: "opus",
+        modelRevisionEpoch: "01900000-0000-7000-8000-000000000001",
+        modelRevision: 17,
+        availableModels: [
+          { value: "sonnet", label: "Sonnet" },
+          { value: "opus", label: "Opus" },
+        ],
+      },
+    ];
+    insertHistoryRow({
+      id: "hist-model",
+      agentId: "agent-hist",
+      acpSessionId: "proto-hist",
+      parentConversationId: "conv-model",
+      startedAt: 1000,
+      status: "completed",
+    });
+
+    const handler = getSessionsHandler();
+    const body = (await handler({})) as ResponseShape;
+    const live = body.sessions.find((s) => s.id === "live-model");
+    const hist = body.sessions.find((s) => s.id === "hist-model");
+    expect(live).toMatchObject({
+      model: "opus",
+      modelRevisionEpoch: "01900000-0000-7000-8000-000000000001",
+      modelRevision: 17,
+      availableModels: [
+        { value: "sonnet", label: "Sonnet" },
+        { value: "opus", label: "Opus" },
+      ],
+    });
+    // A finished run has no live process to ask, so it reports neither.
+    expect(hist?.model).toBeUndefined();
+    expect(hist?.availableModels).toBeUndefined();
+  });
+
+  test("omits the model for history rows written without one", async () => {
+    insertHistoryRow({ id: "hist-no-model", status: "completed" });
+
+    const handler = getSessionsHandler();
+    const body = (await handler({})) as ResponseShape;
+    const s = body.sessions.find((row) => row.id === "hist-no-model");
+    expect(s?.model).toBeUndefined();
+  });
+
   test("dedupes by id with in-memory winning on collision", async () => {
     // Same id in both layers — in-memory entry should win and its eventLog
     // comes from the live ring buffer (empty here), not the stale history row.
@@ -579,6 +660,8 @@ describe("POST /v1/acp/spawn: sandboxed bun auto-install on missing binary", ()
       acpSessionId: "acp-route-session",
       protocolSessionId: "proto-route-session",
       agent: "claude",
+      requestedModel: null,
+      effectiveModel: "opus",
     });
     expect(spawnMock).toHaveBeenCalledTimes(1);
     // The real adapter binary is spawned, not a `bun x` wrapper.
@@ -593,7 +676,7 @@ describe("POST /v1/acp/spawn: sandboxed bun auto-install on missing binary", ()
     expect(args).toEqual([
       "add",
       "--global",
-      "@agentclientprotocol/claude-agent-acp",
+      "@agentclientprotocol/claude-agent-acp@0.75.1",
     ]);
   });
 
@@ -680,6 +763,78 @@ describe("POST /v1/acp/spawn: sandboxed bun auto-install on missing binary", ()
   });
 });
 
+describe("POST /v1/acp/spawn: model selection", () => {
+  test("threads the requested model to the session manager", async () => {
+    const handler = getSpawnHandler();
+    const body = (await handler({
+      body: { ...SPAWN_BODY, model: "opus" },
+    })) as Record<string, unknown>;
+
+    expect(confirmationRequests).toHaveLength(1);
+    expect(confirmationRequests[0]?.input).toEqual({
+      agent: "claude",
+      task: "do something",
+      cwd: process.cwd(),
+      model: "opus",
+    });
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    expect((spawnMock.mock.calls[0] as unknown[])[6]).toEqual({
+      model: "opus",
+    });
+
+    expect(body.requestedModel).toBe("opus");
+    expect(body.effectiveModel).toBe("opus");
+  });
+
+  test("reports the manager-normalized requested model", async () => {
+    const handler = getSpawnHandler();
+    const body = (await handler({
+      body: { ...SPAWN_BODY, model: "  opus  " },
+    })) as Record<string, unknown>;
+
+    expect((spawnMock.mock.calls[0] as unknown[])[6]).toEqual({
+      model: "  opus  ",
+    });
+    expect(body.requestedModel).toBe("opus");
+  });
+
+  test("a spawn that names no model asks the manager for none", async () => {
+    const handler = getSpawnHandler();
+    await handler({ body: SPAWN_BODY });
+
+    const options = (spawnMock.mock.calls[0] as unknown[])[6] as {
+      model?: string;
+    };
+    const approvalInput = confirmationRequests[0]?.input as Record<
+      string,
+      unknown
+    >;
+    expect(approvalInput).not.toHaveProperty("model");
+    expect(options.model).toBeUndefined();
+  });
+
+  test("a refused model is a warning on an otherwise successful spawn", async () => {
+    spawnResult = {
+      ...DEFAULT_SPAWN_RESULT,
+      modelWarning: "Invalid value for config option model: nope",
+    };
+
+    const handler = getSpawnHandler();
+    const body = (await handler({
+      body: { ...SPAWN_BODY, model: "nope" },
+    })) as Record<string, unknown>;
+
+    expect(body).toEqual({
+      acpSessionId: "acp-route-session",
+      protocolSessionId: "proto-route-session",
+      agent: "claude",
+      requestedModel: "nope",
+      effectiveModel: "opus",
+      modelWarning: "Invalid value for config option model: nope",
+    });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // POST /v1/acp/:id/steer: transparent resume of sessions not in memory
 // ---------------------------------------------------------------------------

package/src/runtime/routes/__tests__/apps-refresh-route.test.ts

@@ -0,0 +1,275 @@
+/**
+ * Tests for POST apps/:id/refresh (apps_refresh) in the shared route table.
+ *
+ * `mock.module` is process-global in Bun. Stubs delegate to the real
+ * implementations unless this file's tests are running.
+ */
+
+import { mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import type { CompileResult } from "../../../bundler/app-compiler.js";
+
+let mockActive = false;
+beforeAll(() => {
+  mockActive = true;
+});
+afterAll(() => {
+  mockActive = false;
+});
+
+const realCompiler = { ...(await import("../../../bundler/app-compiler.js")) };
+const realNotify = {
+  ...(await import("../../../daemon/app-change-notify.js")),
+};
+const realPinStore = {
+  ...(await import("../../../apps/app-pin-store.js")),
+};
+
+const compileApp = mock(
+  async (
+    _appDir: Parameters<typeof realCompiler.compileApp>[0],
+  ): Promise<CompileResult> => ({
+    ok: true,
+    errors: [],
+    warnings: [],
+    durationMs: 11,
+  }),
+);
+const notifyAppSurfacesChanged = mock(
+  (..._args: Parameters<typeof realNotify.notifyAppSurfacesChanged>) => {},
+);
+
+mock.module("../../../bundler/app-compiler.js", () => ({
+  ...realCompiler,
+  compileApp: (...args: Parameters<typeof realCompiler.compileApp>) => {
+    if (!mockActive) {
+      return realCompiler.compileApp(...args);
+    }
+    return compileApp(...args);
+  },
+}));
+
+mock.module("../../../daemon/app-change-notify.js", () => ({
+  ...realNotify,
+  notifyAppSurfacesChanged: (
+    ...args: Parameters<typeof realNotify.notifyAppSurfacesChanged>
+  ) => {
+    if (!mockActive) {
+      return realNotify.notifyAppSurfacesChanged(...args);
+    }
+    return notifyAppSurfacesChanged(...args);
+  },
+}));
+
+mock.module("../../../apps/app-pin-store.js", () => ({
+  ...realPinStore,
+  listAppPins: () => {
+    if (!mockActive) {
+      return realPinStore.listAppPins();
+    }
+    return [];
+  },
+}));
+
+const { createApp } = await import("../../../apps/app-store.js");
+const { getWorkspacePluginsDir } = await import("../../../util/platform.js");
+const { ROUTES } = await import("../app-management-routes.js");
+
+function findHandler(operationId: string) {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route.handler;
+}
+
+const handleRefreshApp = findHandler("apps_refresh");
+const handleListApps = findHandler("apps_list");
+
+let workspaceDir: string;
+let previousWorkspaceDir: string | undefined;
+
+beforeEach(() => {
+  previousWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-apps-refresh-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  compileApp.mockClear();
+  notifyAppSurfacesChanged.mockClear();
+  compileApp.mockResolvedValue({
+    ok: true,
+    errors: [],
+    warnings: [],
+    durationMs: 11,
+  });
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+  if (previousWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceDir;
+  }
+});
+
+describe("apps_refresh route", () => {
+  test("is registered on the shared app-management ROUTES table", () => {
+    expect(typeof handleRefreshApp).toBe("function");
+  });
+
+  test("compiles a workspace app and notifies surfaces", async () => {
+    const created = createApp({
+      name: "Budget",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Budget</h1>",
+    });
+
+    const result = await handleRefreshApp({
+      pathParams: { id: created.id },
+    });
+
+    expect(compileApp).toHaveBeenCalled();
+    expect(notifyAppSurfacesChanged).toHaveBeenCalledWith(created.id, {
+      fileChange: true,
+    });
+    expect(result).toEqual({
+      ok: true,
+      appId: created.id,
+      name: "Budget",
+      compiled: true,
+      compile_duration_ms: 11,
+    });
+  });
+
+  test("advances the workspace app list revision when compiled output changes", async () => {
+    const created = createApp({
+      name: "Budget",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Budget</h1>",
+    });
+    const builtAt = Math.ceil(created.updatedAt) + 1_000;
+    compileApp.mockImplementationOnce(async (appDir) => {
+      const distDir = join(appDir, "dist");
+      mkdirSync(distDir, { recursive: true });
+      utimesSync(distDir, new Date(builtAt), new Date(builtAt));
+      return { ok: true, errors: [], warnings: [], durationMs: 11 };
+    });
+
+    await handleRefreshApp({ pathParams: { id: created.id } });
+    const listed = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+
+    expect(listed.apps.find((app) => app.id === created.id)?.updatedAt).toBe(
+      builtAt,
+    );
+  });
+
+  test("compiles a plugin app in place", async () => {
+    const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
+    const pluginDir = join(getWorkspacePluginsDir(), pluginName);
+    mkdirSync(join(pluginDir, "apps", "viewer"), { recursive: true });
+    writeFileSync(
+      join(pluginDir, "package.json"),
+      JSON.stringify({ name: pluginName, version: "1.0.0" }),
+    );
+    writeFileSync(join(pluginDir, "apps", "viewer", "index.html"), "<h1></h1>");
+    const pluginAppId = `plugins~${pluginName}~viewer`;
+
+    const result = await handleRefreshApp({
+      pathParams: { id: pluginAppId },
+    });
+
+    expect(compileApp).toHaveBeenCalledWith(join(pluginDir, "apps", "viewer"));
+    expect(notifyAppSurfacesChanged).toHaveBeenCalledWith(pluginAppId, {
+      fileChange: true,
+    });
+    expect(result).toMatchObject({
+      ok: true,
+      appId: pluginAppId,
+      name: "viewer",
+      compiled: true,
+    });
+  });
+
+  test("advances the plugin app list revision when compiled output changes", async () => {
+    const pluginName = `charts-${Math.random().toString(36).slice(2, 8)}`;
+    const appDir = join(getWorkspacePluginsDir(), pluginName, "apps", "viewer");
+    mkdirSync(appDir, { recursive: true });
+    writeFileSync(
+      join(getWorkspacePluginsDir(), pluginName, "package.json"),
+      JSON.stringify({ name: pluginName, version: "1.0.0" }),
+    );
+    const pluginAppId = `plugins~${pluginName}~viewer`;
+    const before = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+    const previousRevision = before.apps.find(
+      (app) => app.id === pluginAppId,
+    )?.updatedAt;
+    expect(previousRevision).toBeDefined();
+    const builtAt = Math.ceil(previousRevision!) + 1_000;
+    compileApp.mockImplementationOnce(async (sourceDir) => {
+      const distDir = join(sourceDir, "dist");
+      mkdirSync(distDir, { recursive: true });
+      utimesSync(distDir, new Date(builtAt), new Date(builtAt));
+      return { ok: true, errors: [], warnings: [], durationMs: 11 };
+    });
+
+    await handleRefreshApp({ pathParams: { id: pluginAppId } });
+    const after = (await handleListApps({})) as {
+      apps: Array<{ id: string; updatedAt: number }>;
+    };
+
+    expect(after.apps.find((app) => app.id === pluginAppId)?.updatedAt).toBe(
+      builtAt,
+    );
+  });
+
+  test("returns compile errors without throwing", async () => {
+    const created = createApp({
+      name: "Budget",
+      schemaJson: "{}",
+      htmlDefinition: "<h1>Budget</h1>",
+    });
+    compileApp.mockImplementationOnce(async () => ({
+      ok: false,
+      errors: [{ text: "Could not resolve foo" }],
+      warnings: [],
+      durationMs: 4,
+    }));
+
+    const result = await handleRefreshApp({
+      pathParams: { id: created.id },
+    });
+
+    expect(result).toMatchObject({
+      compiled: false,
+      compile_errors: [{ text: "Could not resolve foo" }],
+    });
+    expect(notifyAppSurfacesChanged).toHaveBeenCalled();
+  });
+
+  test("throws not found for an unknown app", async () => {
+    await expect(
+      handleRefreshApp({ pathParams: { id: "missing" } }),
+    ).rejects.toMatchObject({
+      statusCode: 404,
+    });
+  });
+});

package/src/runtime/routes/__tests__/channel-send-routes.test.ts

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// The route is a thin door over the send function: it validates the body
+// against its declared schema and maps the function's refusals onto route
+// errors, so the CLI and the messaging tool share one seam.
+
+const sendCalls: Array<Record<string, unknown>> = [];
+let sendImpl: (params: Record<string, unknown>) => Promise<unknown> = async (
+  params,
+) => ({
+  channel: params.channel,
+  chatId: "C123",
+  messageIds: ["1700000000.000100"],
+  lastMessageId: "1700000000.000100",
+  recordedIn: "home-1",
+});
+
+class ChannelNotAddressableError extends Error {}
+class ChannelSendFailedError extends Error {}
+
+mock.module("../../channel-send.js", () => ({
+  ChannelNotAddressableError,
+  ChannelSendFailedError,
+  sendChannelText: async (params: Record<string, unknown>) => {
+    sendCalls.push(params);
+    return sendImpl(params);
+  },
+}));
+
+const { ROUTES } = await import("../channel-send-routes.js");
+const { BadGatewayError, BadRequestError } = await import("../errors.js");
+
+const route = ROUTES.find((r) => r.operationId === "channels_send_post")!;
+
+beforeEach(() => {
+  sendCalls.length = 0;
+});
+
+describe("POST channels/send", () => {
+  test("is registered as a chat write for actor principals", () => {
+    expect(route).toBeDefined();
+    expect(route.endpoint).toBe("channels/send");
+    expect(route.method).toBe("POST");
+    expect(route.policy?.requiredScopes).toEqual(["chat.write"]);
+  });
+
+  test("hands a valid body to the send function and returns its result", async () => {
+    const body = {
+      channel: "slack",
+      target: { kind: "chat", chatId: "C123", threadId: "1690000000.000001" },
+      text: "hello",
+      renderRichly: true,
+    };
+    const result = await route.handler({ body });
+    expect(sendCalls).toEqual([body]);
+    expect(result).toMatchObject({
+      channel: "slack",
+      messageIds: ["1700000000.000100"],
+      recordedIn: "home-1",
+    });
+  });
+
+  test("names no sending turn, so a caller cannot claim a send was its own chat's", async () => {
+    await route.handler({
+      body: {
+        channel: "slack",
+        target: { kind: "chat", chatId: "C123" },
+        text: "hello",
+        sender: {
+          conversationId: "conv-A",
+          executionChannel: "slack",
+          requesterChatId: "C123",
+        },
+      },
+    });
+    expect(sendCalls).toHaveLength(1);
+    expect(sendCalls[0]).not.toHaveProperty("sender");
+  });
+
+  test("rejects a malformed body before calling the send function", async () => {
+    await expect(
+      route.handler({
+        body: { channel: "slack", target: { kind: "chat" }, text: "" },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    await expect(
+      route.handler({
+        body: {
+          channel: "not-a-channel",
+          target: { kind: "chat", chatId: "C1" },
+          text: "hi",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    expect(sendCalls).toEqual([]);
+  });
+
+  test("maps the send function's refusals onto route errors", async () => {
+    sendImpl = async () => {
+      throw new ChannelNotAddressableError(
+        'Channel "email" is not addressable',
+      );
+    };
+    await expect(
+      route.handler({
+        body: {
+          channel: "email",
+          target: { kind: "chat", chatId: "x" },
+          text: "hi",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+
+    sendImpl = async () => {
+      throw new ChannelSendFailedError("not acknowledged");
+    };
+    await expect(
+      route.handler({
+        body: {
+          channel: "slack",
+          target: { kind: "chat", chatId: "C1" },
+          text: "hi",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadGatewayError);
+  });
+});