@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.4

package/src/tools/browser/browser-execution.ts

@@ -1,3 +1,4 @@
+import { optimizeImageForTransport } from "../../agent/image-optimize.js";
 import { getConfig } from "../../config/loader.js";
 import { HostBrowserProxy } from "../../daemon/host-browser-proxy.js";
 import type { ImageContent } from "../../providers/types.js";
@@ -1206,13 +1207,22 @@ export async function executeBrowserScreenshot(
       { quality: 80, fullPage },
       context.signal,
     );
-    const base64Data = buffer.toString("base64");
+    const rawBase64 = buffer.toString("base64");
+
+    // Downscale before handing the screenshot to the model. A full-page
+    // capture of a tall or high-DPI page can exceed Anthropic's 5 MB
+    // per-image cap, which would otherwise persist into the conversation
+    // history inside this tool_result and reject every subsequent turn.
+    const { data: base64Data, mediaType } = optimizeImageForTransport(
+      rawBase64,
+      "image/jpeg",
+    );
 
     const imageBlock: ImageContent = {
       type: "image" as const,
       source: {
         type: "base64" as const,
-        media_type: "image/jpeg",
+        media_type: mediaType,
         data: base64Data,
       },
     };

package/src/tools/network/web-fetch.ts

@@ -152,25 +152,56 @@ function isNullBodyStatus(status: number): boolean {
   return status === 204 || status === 205 || status === 304;
 }
 
+// The WHATWG `Response` constructor only accepts 101 or the range 200–599 and
+// throws a `RangeError` for anything else. Some servers — notably anti-bot
+// gateways like LinkedIn and various job boards — reply with non-standard codes
+// such as 999. Map those onto 502 so we can still build a Response; the real
+// upstream status is preserved via `upstreamStatusByResponse` for reporting.
+// See https://developer.mozilla.org/en-US/docs/Web/API/Response/Response
+const RESPONSE_STATUS_SWITCHING_PROTOCOLS = 101;
+const RESPONSE_STATUS_MIN = 200;
+const RESPONSE_STATUS_MAX = 599;
+
+function toConstructableStatus(status: number): number {
+  if (status === RESPONSE_STATUS_SWITCHING_PROTOCOLS) return status;
+  if (status >= RESPONSE_STATUS_MIN && status <= RESPONSE_STATUS_MAX) {
+    return status;
+  }
+  return 502;
+}
+
+const upstreamStatusByResponse = new WeakMap<Response, number>();
+
+// Returns the real status the upstream server sent, which may fall outside the
+// range the `Response` object can represent (e.g. 999). Falls back to
+// `response.status` for responses built by native `fetch`, whose undici
+// implementation already exposes non-standard codes directly.
+export function getUpstreamStatus(response: Response): number {
+  return upstreamStatusByResponse.get(response) ?? response.status;
+}
+
 export function buildFetchResponseFromNodeResponse(
   res: NodeHttpResponseLike,
 ): Response {
-  const status = res.statusCode ?? 502;
+  const upstreamStatus = res.statusCode ?? 502;
+  const status = toConstructableStatus(upstreamStatus);
   const responseHeaders = buildResponseHeaders(res.headers);
   const statusText = res.statusMessage ?? "";
 
-  if (isNullBodyStatus(status)) {
-    // Drain any unexpected bytes and produce a valid null-body fetch Response.
-    res.resume();
-    return new Response(null, { status, statusText, headers: responseHeaders });
-  }
+  const response = isNullBodyStatus(status)
+    ? // Drain any unexpected bytes and produce a valid null-body fetch Response.
+      (res.resume(),
+      new Response(null, { status, statusText, headers: responseHeaders }))
+    : new Response(Readable.toWeb(res) as unknown as BodyInit, {
+        status,
+        statusText,
+        headers: responseHeaders,
+      });
 
-  const body = Readable.toWeb(res);
-  return new Response(body as unknown as BodyInit, {
-    status,
-    statusText,
-    headers: responseHeaders,
-  });
+  if (status !== upstreamStatus) {
+    upstreamStatusByResponse.set(response, upstreamStatus);
+  }
+  return response;
 }
 
 function createAbortError(): Error {
@@ -252,7 +283,16 @@ const defaultRequestExecutor: WebFetchRequestExecutor = async (
 
   return await new Promise<Response>((resolve, reject) => {
     const req = requestFn(requestOptions, (res) => {
-      resolve(buildFetchResponseFromNodeResponse(res));
+      // Building the fetch Response runs inside this HTTP `response` event
+      // callback. Any synchronous throw here would escape as an uncaught
+      // exception and crash the daemon, so funnel failures into `reject` to
+      // keep them local to this request.
+      try {
+        resolve(buildFetchResponseFromNodeResponse(res));
+      } catch (err) {
+        res.resume();
+        reject(err);
+      }
     });
     req.once("error", reject);
     req.end();
@@ -730,9 +770,10 @@ export async function executeWebFetch(
         );
       }
 
+      const upstreamStatus = getUpstreamStatus(response);
       const location = response.headers.get("location");
       const isRedirect =
-        response.status >= 300 && response.status < 400 && !!location;
+        upstreamStatus >= 300 && upstreamStatus < 400 && !!location;
       if (!isRedirect) break;
 
       if (redirectCount >= MAX_REDIRECTS) {
@@ -741,7 +782,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -761,7 +802,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -773,7 +814,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -785,7 +826,7 @@ export async function executeWebFetch(
           {
             url: requestedUrl,
             finalUrl: currentUrl.href,
-            status: response.status,
+            status: getUpstreamStatus(response),
             redirectCount,
           },
         );
@@ -805,7 +846,7 @@ export async function executeWebFetch(
             {
               url: requestedUrl,
               finalUrl: currentUrl.href,
-              status: response.status,
+              status: getUpstreamStatus(response),
               redirectCount,
             },
           );
@@ -817,7 +858,7 @@ export async function executeWebFetch(
             {
               url: requestedUrl,
               finalUrl: currentUrl.href,
-              status: response.status,
+              status: getUpstreamStatus(response),
               redirectCount,
             },
           );
@@ -844,7 +885,7 @@ export async function executeWebFetch(
         {
           url: requestedUrl,
           finalUrl: currentUrl.href,
-          status: response.status,
+          status: getUpstreamStatus(response),
           contentType,
           redirectCount,
         },
@@ -909,7 +950,7 @@ export async function executeWebFetch(
     const content = formatWebFetchOutput({
       requestedUrl: safeRequestedUrl,
       finalUrl: sanitizeUrlForOutput(currentUrl),
-      status: response.status,
+      status: getUpstreamStatus(response),
       statusText: response.statusText,
       contentType,
       bytesRead: body.bytesRead,
@@ -931,7 +972,7 @@ export async function executeWebFetch(
     const meta: WebFetchMetadata = {
       url: safeRequestedUrl,
       finalUrl: sanitizeUrlForOutput(currentUrl),
-      status: response.status,
+      status: getUpstreamStatus(response),
       contentType: contentType || undefined,
       byteCount: body.bytesRead,
       charCount: sliced.length,
@@ -945,7 +986,7 @@ export async function executeWebFetch(
     };
 
     if (!response.ok) {
-      const errorMessage = `Error: HTTP ${response.status}`;
+      const errorMessage = `Error: HTTP ${getUpstreamStatus(response)}`;
       return {
         content: `${errorMessage}\n\n${content}`,
         isError: true,

package/src/tools/skills/load.ts

@@ -128,7 +128,7 @@ export const skillLoadTool = {
   name: "skill_load",
 
   description:
-    'Load full instructions for a skill. Works for both bundled skills (listed in the catalog) and custom workspace skills. For app, website, dashboard, game, calculator, tracker, visualization, or interactive tool requests, load `app-builder` with `skill: "app-builder"`.',
+    'Load full instructions for a skill. Works for both bundled skills (listed in the catalog) and custom workspace skills. Bundled/first-party skills (like `app-builder`) are already installed — loading only activates their instructions for the current conversation, since skills unload between turns; treat "load" as activation, not installation, and don\'t tell users a bundled skill needs installing. Loading can still fail (e.g. a feature-gated skill returns "currently unavailable", or the load errors) — if it does, relay that specific error rather than claiming the skill is not installed or offering to install it. For app, website, dashboard, game, calculator, tracker, visualization, or interactive tool requests, load `app-builder` with `skill: "app-builder"`.',
 
   category: "skills",
 

package/src/tools/ui-surface/definitions.ts

@@ -8,6 +8,7 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
+import { ACTIVATION_MOMENT_PARAMS } from "../../telemetry/activation-funnel.js";
 import type {
   ToolContext,
   ToolDefinition,
@@ -204,6 +205,12 @@ export const uiShowTool = {
         description:
           "When true, clicking an action does not dismiss the surface — the card stays visible and only the clicked action is marked as spent. Use for launcher or menu-style cards where multiple buttons may be clicked. Defaults to false.",
       },
+      activation_moment: {
+        type: "string",
+        enum: ACTIVATION_MOMENT_PARAMS,
+        description:
+          "Activation-rail telemetry tag (cohort only). Set this when this surface IS one of the activation funnel moments; the milestone is recorded automatically when the user commits the surface. Omit for all non-activation surfaces.",
+      },
     },
     required: ["surface_type", "data"],
   },

package/src/acp/feature-gate.test.ts

@@ -1,48 +0,0 @@
-/**
- * Tests for the ACP feature gate.
- *
- * `isAcpEnabled` is an OR of the `acp` feature flag and the legacy
- * `config.acp.enabled` field: either switch enables the subsystem, and
- * neither implicitly flips the other.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../config/schema.js";
-import { ACP_FLAG_KEY, isAcpEnabled } from "./feature-gate.js";
-
-beforeEach(() => {
-  setOverridesForTesting({});
-});
-
-afterEach(() => {
-  setOverridesForTesting({});
-});
-
-/** Minimal AssistantConfig carrying only the `acp` section the gate reads. */
-function makeConfig(acpEnabled: boolean): AssistantConfig {
-  return {
-    acp: { enabled: acpEnabled, maxConcurrentSessions: 4, agents: {} },
-  } as AssistantConfig;
-}
-
-describe("isAcpEnabled", () => {
-  test("returns false when both the flag and config.acp.enabled are off", () => {
-    expect(isAcpEnabled(makeConfig(false))).toBe(false);
-  });
-
-  test("returns true when config.acp.enabled is true and the flag is off", () => {
-    expect(isAcpEnabled(makeConfig(true))).toBe(true);
-  });
-
-  test("returns true when the flag is on and config.acp.enabled is false", () => {
-    setOverridesForTesting({ [ACP_FLAG_KEY]: true });
-    expect(isAcpEnabled(makeConfig(false))).toBe(true);
-  });
-
-  test("explicit flag-off override does not defeat config.acp.enabled", () => {
-    setOverridesForTesting({ [ACP_FLAG_KEY]: false });
-    expect(isAcpEnabled(makeConfig(true))).toBe(true);
-  });
-});

package/src/acp/feature-gate.ts

@@ -1,34 +0,0 @@
-/**
- * ACP (Agent Client Protocol) feature gate.
- *
- * Single source of truth for whether the ACP subsystem is enabled. Modeled
- * on `credential-execution/feature-gates.ts`: the flag key is declared in
- * `meta/feature-flags/feature-flag-registry.json` and resolved through the
- * unified feature-flag resolver.
- *
- * The gate is an OR of two independent switches:
- *   1. `config.acp.enabled` — the original workspace config field. Preserved
- *      so existing workspaces with `acp.enabled: true` keep working without
- *      any migration.
- *   2. The `acp` feature flag — adds a UI toggle. Flag state is persisted by
- *      the gateway and hot-refreshed in the daemon via the
- *      `feature_flags_changed` SSE event, so toggling it takes effect
- *      without a restart or config-file edit.
- */
-
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-
-/** Gate for the ACP coding-agent subsystem (must match the registry). */
-export const ACP_FLAG_KEY = "acp" as const;
-
-/**
- * Whether ACP agent spawning/steering is enabled, via either the legacy
- * `acp.enabled` config field or the `acp` feature flag (see module doc).
- */
-export function isAcpEnabled(config: AssistantConfig): boolean {
-  return (
-    config.acp?.enabled === true ||
-    isAssistantFeatureFlagEnabled(ACP_FLAG_KEY, config)
-  );
-}

package/src/plugins/defaults/memory-v3-shadow/__tests__/assign.test.ts

@@ -1,242 +0,0 @@
-/**
- * Tests for the v3 page→leaf classifier. Uses a stub provider so no live LLM
- * is hit. Pages are written into a temp workspace.
- */
-
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { readPage, writePage } from "../../../../memory/v2/page-store.js";
-import type { ConceptPageFrontmatter } from "../../../../memory/v2/types.js";
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolUseContent,
-} from "../../../../providers/types.js";
-import type { LeafNode, LeafTree } from "../types.js";
-
-// Stub the provider layer before importing `assign.js` so its static import
-// chain (which transitively pulls in CES/credential workspace packages that
-// aren't built in a fresh worktree) never loads. The classifier is
-// provider-injectable, so every test passes its own stub provider — the real
-// `getConfiguredProvider` is never exercised here.
-mock.module("../../../../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: async () => null,
-  extractToolUse: (response: ProviderResponse) =>
-    response.content.find((b): b is ToolUseContent => b.type === "tool_use"),
-  userMessage: (text: string): Message => ({
-    role: "user",
-    content: [{ type: "text", text }],
-  }),
-}));
-
-const { assignPages } = await import("../assign.js");
-
-function makeLeaf(path: string, description: string): LeafNode {
-  return {
-    path,
-    frontmatter: { path, in_core: false },
-    description,
-    members: [],
-    domain: path.split("/")[0],
-  };
-}
-
-function makeTree(leaves: LeafNode[]): LeafTree {
-  return {
-    leaves: new Map(leaves.map((l) => [l.path, l])),
-    byPage: new Map(),
-  };
-}
-
-/** Sorted by path: [1] domain-a/topic-x, [2] domain-a/topic-y, [3] domain-b/topic-z */
-function threeLeafTree(): LeafTree {
-  return makeTree([
-    makeLeaf("domain-b/topic-z", "about z"),
-    makeLeaf("domain-a/topic-x", "about x"),
-    makeLeaf("domain-a/topic-y", "about y"),
-  ]);
-}
-
-function stubProvider(
-  handler: (
-    messages: Message[],
-    options?: SendMessageOptions,
-  ) => ProviderResponse | Promise<ProviderResponse>,
-): Provider {
-  return {
-    name: "stub",
-    sendMessage: async (messages, options) => handler(messages, options),
-  } as Provider;
-}
-
-function response(content: ProviderResponse["content"]): ProviderResponse {
-  return {
-    content,
-    model: "stub-model",
-    stopReason: "tool_use",
-    usage: { inputTokens: 0, outputTokens: 0 },
-  };
-}
-
-function toolResponse(ids: unknown[]): ProviderResponse {
-  return response([
-    { type: "tool_use", id: "tu-1", name: "assign_leaves", input: { ids } },
-  ]);
-}
-
-function textResponse(text: string): ProviderResponse {
-  return response([{ type: "text", text }]);
-}
-
-let workspaceDir: string;
-
-beforeEach(async () => {
-  workspaceDir = await mkdtemp(join(tmpdir(), "v3-assign-"));
-});
-
-afterEach(async () => {
-  await rm(workspaceDir, { recursive: true, force: true });
-});
-
-async function makePage(
-  slug: string,
-  frontmatter: Partial<ConceptPageFrontmatter>,
-  body = "page body",
-): Promise<void> {
-  await writePage(workspaceDir, {
-    slug,
-    frontmatter: { edges: [], ref_files: [], ref_urls: [], ...frontmatter },
-    body,
-  });
-}
-
-describe("assignPages", () => {
-  test("unions classified picks with prior picks, never overwriting", async () => {
-    await makePage("page-a", { leaves: ["domain-a/topic-x"] });
-    // Classifier returns [2] -> domain-a/topic-y and [1] -> already present.
-    const provider = stubProvider(() => toolResponse([2, 1]));
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider,
-      throttleMs: 0,
-    });
-
-    expect(results).toEqual([
-      {
-        slug: "page-a",
-        before: ["domain-a/topic-x"],
-        after: ["domain-a/topic-x", "domain-a/topic-y"],
-        failed: false,
-      },
-    ]);
-
-    const written = await readPage(workspaceDir, "page-a");
-    expect(written?.frontmatter.leaves).toEqual([
-      "domain-a/topic-x",
-      "domain-a/topic-y",
-    ]);
-  });
-
-  test("classification failure leaves the page's leaves unchanged", async () => {
-    await makePage("page-a", { leaves: ["domain-b/topic-z"] });
-
-    // (a) provider throws
-    const throwing = stubProvider(() => {
-      throw new Error("boom");
-    });
-    let results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: throwing,
-      throttleMs: 0,
-    });
-    expect(results[0]).toEqual({
-      slug: "page-a",
-      before: ["domain-b/topic-z"],
-      after: ["domain-b/topic-z"],
-      failed: true,
-    });
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-
-    // (b) no tool use
-    results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: stubProvider(() => textResponse("no tool here")),
-      throttleMs: 0,
-    });
-    expect(results[0].failed).toBe(true);
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-
-    // (c) empty ids
-    results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider: stubProvider(() => toolResponse([])),
-      throttleMs: 0,
-    });
-    expect(results[0].failed).toBe(true);
-    expect(
-      (await readPage(workspaceDir, "page-a"))?.frontmatter.leaves,
-    ).toEqual(["domain-b/topic-z"]);
-  });
-
-  test("deterministic id->path mapping, dropping out-of-range and 0 ids", async () => {
-    await makePage("page-a", {});
-    // 0 and 99 are invalid; 3 -> domain-b/topic-z; 1 -> domain-a/topic-x.
-    const provider = stubProvider(() => toolResponse([0, 99, 3, 1, -1, 2.5]));
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      slugs: ["page-a"],
-      provider,
-      throttleMs: 0,
-    });
-
-    expect(results[0].after).toEqual(["domain-b/topic-z", "domain-a/topic-x"]);
-    expect(results[0].failed).toBe(false);
-  });
-
-  test("defaults to pages with empty or missing leaves", async () => {
-    await makePage("page-empty", { leaves: [] });
-    await makePage("page-missing", {});
-    await makePage("page-classified", { leaves: ["domain-a/topic-x"] });
-
-    const seen: string[] = [];
-    const provider = stubProvider((messages) => {
-      const text = messages[0]?.content
-        .map((b) => (b.type === "text" ? b.text : ""))
-        .join("");
-      seen.push(text);
-      return toolResponse([2]);
-    });
-
-    const results = await assignPages({
-      tree: threeLeafTree(),
-      workspaceDir,
-      provider,
-      throttleMs: 0,
-    });
-
-    const slugs = results.map((r) => r.slug).sort();
-    expect(slugs).toEqual(["page-empty", "page-missing"]);
-    // The classified page was never sent to the provider.
-    expect(seen.length).toBe(2);
-  });
-});

package/src/plugins/defaults/memory-v3-shadow/__tests__/core.test.ts

@@ -1,39 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
-
-import { loadCore } from "../core.js";
-
-const BUNDLED_DATA_DIR = join(import.meta.dir, "..", "data");
-
-describe("loadCore", () => {
-  let tmpDirs: string[] = [];
-
-  afterEach(async () => {
-    await Promise.all(
-      tmpDirs.map((d) => rm(d, { recursive: true, force: true })),
-    );
-    tmpDirs = [];
-  });
-
-  async function makeTmpDir(): Promise<string> {
-    const dir = await mkdtemp(join(tmpdir(), "v3-core-"));
-    tmpDirs.push(dir);
-    return dir;
-  }
-
-  test("loads alwaysOn from the supplied dataDir's core.json into a Set", async () => {
-    const core = await loadCore(BUNDLED_DATA_DIR);
-    expect(core).toBeInstanceOf(Set);
-    expect(core.has("domain-a/topic-x")).toBe(true);
-    expect(core.size).toBe(1);
-  });
-
-  test("returns empty set when core.json is missing", async () => {
-    const emptyDataDir = await makeTmpDir();
-    const core = await loadCore(emptyDataDir);
-    expect(core).toBeInstanceOf(Set);
-    expect(core.size).toBe(0);
-  });
-});