@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/tools/acp/steer.test.ts

@@ -7,6 +7,7 @@ interface SteerCall {
   instruction: string;
 }
 
+// Direct steer (no connected client -> no resume fallback).
 const steerCalls: SteerCall[] = [];
 const defaultSteer = (acpSessionId: string, instruction: string) => {
   steerCalls.push({ acpSessionId, instruction });
@@ -15,6 +16,13 @@ const defaultSteer = (acpSessionId: string, instruction: string) => {
 let steerImpl: (acpSessionId: string, instruction: string) => Promise<void> =
   defaultSteer;
 
+// steerOrResume (connected client path).
+const steerOrResumeCalls: Array<SteerCall & { send: unknown }> = [];
+let steerOrResumeImpl: (
+  acpSessionId: string,
+  instruction: string,
+) => Promise<{ resumed: boolean }> = async () => ({ resumed: false });
+
 // Spread the real module's exports so transitive importers that pull other
 // names from `../../acp/index.js` still resolve at parse time. Bun's `mock.module` is
 // process-global and returns *exactly* the keys the factory returns.
@@ -24,35 +32,50 @@ mock.module("../../acp/index.js", () => ({
   getAcpSessionManager: () => ({
     steer: (acpSessionId: string, instruction: string) =>
       steerImpl(acpSessionId, instruction),
+    steerOrResume: (
+      acpSessionId: string,
+      instruction: string,
+      send: unknown,
+    ) => {
+      steerOrResumeCalls.push({ acpSessionId, instruction, send });
+      return steerOrResumeImpl(acpSessionId, instruction);
+    },
   }),
 }));
 
 const { executeAcpSteer } = await import("./steer.js");
 
-function makeContext(): ToolContext {
+function makeContext(opts?: { withClient?: boolean }): ToolContext {
   return {
     workingDir: "/tmp",
     conversationId: "conv-test",
     trustClass: "guardian",
-  };
+    ...(opts?.withClient ? { sendToClient: () => {} } : {}),
+  } as ToolContext;
 }
 
 beforeEach(() => {
   steerCalls.length = 0;
+  steerOrResumeCalls.length = 0;
   steerImpl = defaultSteer;
+  steerOrResumeImpl = async () => ({ resumed: false });
 });
 
 describe("executeAcpSteer", () => {
-  test("happy path: returns steered status and forwards args to manager", async () => {
+  test("happy path: returns steered status and forwards args to steerOrResume", async () => {
     const result = await executeAcpSteer(
       { acp_session_id: "acp-123", instruction: "stop, do X instead" },
-      makeContext(),
+      makeContext({ withClient: true }),
     );
 
     expect(result.isError).toBe(false);
-    expect(steerCalls).toEqual([
-      { acpSessionId: "acp-123", instruction: "stop, do X instead" },
-    ]);
+    expect(steerOrResumeCalls).toHaveLength(1);
+    expect(steerOrResumeCalls[0]).toMatchObject({
+      acpSessionId: "acp-123",
+      instruction: "stop, do X instead",
+    });
+    expect(typeof steerOrResumeCalls[0]!.send).toBe("function");
+    expect(steerCalls).toEqual([]);
 
     const parsed = JSON.parse(result.content as string);
     expect(parsed).toEqual({
@@ -71,6 +94,7 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('"instruction" is required');
     expect(steerCalls).toEqual([]);
+    expect(steerOrResumeCalls).toEqual([]);
   });
 
   test("missing acp_session_id returns isError", async () => {
@@ -82,9 +106,23 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('"acp_session_id" is required');
     expect(steerCalls).toEqual([]);
+    expect(steerOrResumeCalls).toEqual([]);
+  });
+
+  test("no connected client: steers directly and never resumes", async () => {
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-direct", instruction: "redirect" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(steerCalls).toEqual([
+      { acpSessionId: "acp-direct", instruction: "redirect" },
+    ]);
+    expect(steerOrResumeCalls).toEqual([]);
   });
 
-  test("manager.steer throwing 'session not found' surfaces the error", async () => {
+  test("'session not found' without a connected client surfaces the error", async () => {
     steerImpl = () =>
       Promise.reject(new Error('ACP session "acp-x" not found'));
 
@@ -96,5 +134,64 @@ describe("executeAcpSteer", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain('Could not steer ACP session "acp-x"');
     expect(result.content).toContain("not found");
+    expect(steerOrResumeCalls).toEqual([]);
+  });
+
+  test("resumed session reports the resumed flag and message", async () => {
+    steerOrResumeImpl = async () => ({ resumed: true });
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-gone", instruction: "keep going" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(steerOrResumeCalls).toHaveLength(1);
+
+    const parsed = JSON.parse(result.content as string);
+    expect(parsed).toEqual({
+      acpSessionId: "acp-gone",
+      status: "steered",
+      resumed: true,
+      message:
+        "Session was resumed from history; new instruction is now running.",
+    });
+  });
+
+  test("resume failure returns its actionable error message", async () => {
+    steerOrResumeImpl = () =>
+      Promise.reject(
+        new Error(
+          'ACP session "acp-legacy" was recorded before resume support (no working directory persisted) and cannot be resumed. Spawn a new session instead.',
+        ),
+      );
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-legacy", instruction: "more work" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'Could not steer ACP session "acp-legacy"',
+    );
+    expect(result.content).toContain("recorded before resume support");
+  });
+
+  test("plain steer errors surface unchanged", async () => {
+    steerOrResumeImpl = () =>
+      Promise.reject(
+        new Error(
+          'ACP session "acp-init" is not running (status: initializing)',
+        ),
+      );
+
+    const result = await executeAcpSteer(
+      { acp_session_id: "acp-init", instruction: "redirect" },
+      makeContext({ withClient: true }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("is not running");
   });
 });

package/src/tools/acp/steer.ts

@@ -1,9 +1,10 @@
 import { getAcpSessionManager } from "../../acp/index.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
+import { getSendToClient } from "./context.js";
 
 export async function executeAcpSteer(
   input: Record<string, unknown>,
-  _context: ToolContext,
+  context: ToolContext,
 ): Promise<ToolExecutionResult> {
   const acpSessionId = input.acp_session_id as string;
   if (!acpSessionId) {
@@ -15,24 +16,54 @@ export async function executeAcpSteer(
     return { content: '"instruction" is required.', isError: true };
   }
 
-  try {
-    const manager = getAcpSessionManager();
-    await manager.steer(acpSessionId, instruction);
+  const manager = getAcpSessionManager();
+  const sendToClient = getSendToClient(context);
 
-    return {
-      content: JSON.stringify({
-        acpSessionId,
-        status: "steered",
-        message:
-          "Interrupted in-flight prompt; new instruction is now running.",
-      }),
-      isError: false,
-    };
+  try {
+    if (!sendToClient) {
+      // Without a connected client there is no one to receive a resumed
+      // session's events, so skip the transparent resume fallback and
+      // steer the in-memory session only.
+      await manager.steer(acpSessionId, instruction);
+      return steeredResult(acpSessionId, { resumed: false });
+    }
+    // Sessions no longer in memory (completed, or lost to a daemon
+    // restart) are transparently resumed from persisted history and the
+    // instruction fired in the same call. Failure messages carry the
+    // actionable hint (e.g. "recorded before resume support", agent
+    // capability missing).
+    const { resumed } = await manager.steerOrResume(
+      acpSessionId,
+      instruction,
+      sendToClient,
+    );
+    return steeredResult(acpSessionId, { resumed });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return {
-      content: `Could not steer ACP session "${acpSessionId}": ${msg}`,
-      isError: true,
-    };
+    return steerError(acpSessionId, msg);
   }
 }
+
+function steeredResult(
+  acpSessionId: string,
+  opts: { resumed: boolean },
+): ToolExecutionResult {
+  return {
+    content: JSON.stringify({
+      acpSessionId,
+      status: "steered",
+      ...(opts.resumed ? { resumed: true } : {}),
+      message: opts.resumed
+        ? "Session was resumed from history; new instruction is now running."
+        : "Interrupted in-flight prompt; new instruction is now running.",
+    }),
+    isError: false,
+  };
+}
+
+function steerError(acpSessionId: string, msg: string): ToolExecutionResult {
+  return {
+    content: `Could not steer ACP session "${acpSessionId}": ${msg}`,
+    isError: true,
+  };
+}

package/src/tools/apps/executors.ts

@@ -76,14 +76,12 @@ export interface AppCreateInput {
   name: string;
   description?: string;
   schema_json?: string;
-  /**
-   * Retired single-file shortcut. Kept in the type so legacy or stale callers
-   * get a clear tool error instead of silently creating a v2 app with stale
-   * scaffold content.
-   */
+  /** Retired single-file shortcut. Returns a guidance error. */
   html?: unknown;
-  /** Retired single-file multi-page shortcut. */
+  /** Retired single-file multi-page shortcut. Returns a guidance error. */
   pages?: unknown;
+  /** Lenient alias. Folded into preview.icon when preview.icon is absent. */
+  icon?: unknown;
   auto_open?: boolean;
   preview?: Record<string, unknown>;
   source_files?: Record<string, string>;
@@ -98,11 +96,14 @@ export async function executeAppCreate(
   const description = input.description;
   const schemaJson = input.schema_json ?? "{}";
 
+  // Retired shortcut: a top-level `html` is no longer accepted. Reject with a
+  // helpful message (rather than a cryptic schema error) so the model writes a
+  // multi-file TSX app under src/ instead.
   if (Object.prototype.hasOwnProperty.call(input, "html")) {
     return {
       content: JSON.stringify({
         error:
-          "app_create no longer accepts html. Create the app scaffold, write src/index.html and src/main.tsx with file_write, then call app_refresh.",
+          "app_create no longer accepts html. Build a multi-file TSX app under src/ (src/index.html + src/main.tsx + src/App.tsx) instead.",
       }),
       isError: true,
     };
@@ -157,7 +158,11 @@ export async function executeAppCreate(
 
   // Extract icon from preview if provided - only persist emoji-like values,
   // not URLs which would render as raw strings in UI and bundle manifests.
-  const rawIcon = preview?.icon as string | undefined;
+  // Lenient alias: a top-level `icon` is folded in when preview.icon is absent.
+  const rawIcon = (preview?.icon ??
+    (typeof input.icon === "string" ? input.icon : undefined)) as
+    | string
+    | undefined;
   const icon = rawIcon && !rawIcon.startsWith("http") ? rawIcon : undefined;
 
   const app = store.createApp({

package/src/tools/executor.ts

@@ -1,18 +1,10 @@
 import { readFileSync } from "node:fs";
 
-import { parseChannelId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { bridgeCesApproval } from "../credential-execution/approval-bridge.js";
 import { isCesShellLockdownEnabled } from "../credential-execution/feature-gates.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { RiskLevel } from "../permissions/types.js";
-import { runPipeline } from "../plugins/pipeline.js";
-import { getMiddlewaresFor } from "../plugins/registry.js";
-import type {
-  ToolExecuteArgs,
-  ToolExecuteResult,
-  TurnContext,
-} from "../plugins/types.js";
 import { isUntrustedTrustClass } from "../runtime/actor-trust-resolver.js";
 import { redactSensitiveFields } from "../security/redaction.js";
 import { TokenExpiredError } from "../security/token-manager.js";
@@ -52,54 +44,10 @@ export class ToolExecutor {
     name: string,
     input: Record<string, unknown>,
     context: ToolContext,
-    /**
-     * Optional per-turn context threaded in by the agent loop. Production
-     * sites propagate the orchestrator-built `TurnContext` (real
-     * `conversationId`, trust cascade, attached `contextWindowManager`) so
-     * middleware registered on the `toolExecute` pipeline sees the same
-     * context every other pipeline slot uses. When omitted (CLI/test
-     * invocations that call `ToolExecutor.execute` directly), the executor
-     * synthesizes a fallback context from the {@link ToolContext}.
-     */
-    turnContext?: TurnContext,
   ): Promise<ToolExecutionResult> {
-    // Prefer the orchestrator-supplied `turnContext` so the pipeline sees
-    // the real conversation identity, per-turn trust, and context-window
-    // manager. When absent (CLI / test invocations that bypass the agent
-    // loop), synthesize a minimal context from the `ToolContext`.
-    const turnCtx: TurnContext = turnContext ?? {
-      requestId: context.requestId ?? "",
-      conversationId: context.conversationId,
-      turnIndex: 0,
-      trust: {
-        sourceChannel: parseChannelId(context.executionChannel) ?? "vellum",
-        trustClass: context.trustClass,
-      },
-    };
-
-    const middlewares = getMiddlewaresFor("toolExecute");
     const { name: executionName, input: executionInput } =
       resolveToolInvocationAlias(name, input, context.allowedToolNames);
-    const pipelineArgs: ToolExecuteArgs = {
-      name: executionName,
-      input: executionInput,
-      context,
-    };
-
-    // No pipeline-level timeout: `executeInternal` already wraps the real
-    // tool invocation in `executeWithTimeout`, which is the sole enforcer
-    // of the per-tool budget. The pipeline itself runs untimed so that
-    // upstream phases (permission checks, approval waits, middleware) are
-    // not racing the tool budget — only the actual tool call is. Runaway
-    // middleware is a plugin-health concern handled by per-plugin timeouts,
-    // not here.
-    return runPipeline<ToolExecuteArgs, ToolExecuteResult>(
-      "toolExecute",
-      middlewares,
-      (args) => this.executeInternal(args.name, args.input, args.context),
-      pipelineArgs,
-      turnCtx,
-    );
+    return this.executeInternal(executionName, executionInput, context);
   }
 
   private async executeInternal(

package/src/tools/filesystem/write.ts

@@ -1,5 +1,6 @@
 import { join, resolve, sep } from "node:path";
 
+import { getAppsDir } from "../../memory/app-store.js";
 import { enqueuePkbIndexJob } from "../../memory/jobs/embed-pkb-file.js";
 import { PKB_WORKSPACE_SCOPE } from "../../memory/pkb/types.js";
 import { RiskLevel } from "../../permissions/types.js";
@@ -17,6 +18,29 @@ import type {
 
 const logger = getLogger("file-write");
 
+/**
+ * Detects an attempt to write a self-contained interactive HTML document —
+ * the signature of a "visualization" / "artifact" the model should be
+ * building as a real app via the app-builder skill, not dumping as a loose
+ * file. We deliberately trip ONLY on standalone docs with a substantial
+ * INLINE script (the data + rendering live in the file). app-builder's own
+ * scaffold writes a thin shell whose only script is an external module
+ * (`<script type="module" src="/src/main.tsx">`) with an empty body, so this
+ * never blocks the app-builder workflow it redirects to.
+ */
+const STANDALONE_HTML_RE = /<!doctype\s+html|<html[\s>]/i;
+const INLINE_SCRIPT_RE = /<script\b(?![^>]*\bsrc=)[^>]*>[\s\S]{400,}?<\/script>/i;
+
+function isSelfContainedArtifactHtml(path: string, content: string): boolean {
+  if (!/\.html?$/i.test(path)) return false;
+  if (content.length < 3000) return false;
+  if (!STANDALONE_HTML_RE.test(content)) return false;
+  return INLINE_SCRIPT_RE.test(content);
+}
+
+const ARTIFACT_REDIRECT_MESSAGE =
+  'Error: This looks like a self-contained interactive visualization/artifact written as a loose HTML file. Do not build these as standalone .html files. Load the app-builder skill first with `skill_load` using `skill: "app-builder"`, then build it as a real persistent app with `app_create` (the skill loads frontend-design for the visual pass and provides chart widgets). If this genuinely needs to be a raw HTML file inside an existing code project, write it under that project folder.';
+
 /**
  * Returns `true` iff `absPath` is an absolute path that resolves strictly
  * inside `pkbRoot`. Matches the containment semantics used elsewhere in the
@@ -82,6 +106,16 @@ export const fileWriteTool = {
       };
     }
 
+    // Redirect self-contained interactive HTML artifacts to app-builder.
+    // Exempt writes that land inside the apps directory (app-builder's own
+    // scaffold/iteration writes) so we never block the workflow we point to.
+    if (isSelfContainedArtifactHtml(rawPath, fileContent)) {
+      const candidate = resolve(context.workingDir, rawPath);
+      if (!isInsidePkbRoot(candidate, getAppsDir())) {
+        return { content: ARTIFACT_REDIRECT_MESSAGE, isError: true };
+      }
+    }
+
     const ops = new FileSystemOps((path, opts) =>
       sandboxPolicy(path, context.workingDir, opts),
     );

package/src/tools/network/__tests__/web-search-metadata.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../web-search-error.js";
+
 // Mutable mock state - set per test
 let mockWebSearchProvider: string | undefined = "perplexity";
 let mockBraveSecureKey: string | undefined;
@@ -32,7 +34,9 @@ mock.module("../../../security/secure-keys.js", () => ({
   },
 }));
 
+const realLogger = await import("../../../util/logger.js");
 mock.module("../../../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
@@ -169,7 +173,9 @@ describe("web_search activity metadata", () => {
     expect(meta.provider).toBe("perplexity");
     expect(meta.resultCount).toBe(0);
     expect(meta.results).toEqual([]);
-    expect(meta.errorMessage).toContain("rate limit exceeded");
+    // Post-retry rate limits now surface the centralized friendly recoverable
+    // copy (ATL-727) rather than provider-specific rate-limit wording.
+    expect(meta.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
   });
 
   // ---- Tavily -------------------------------------------------------------

package/src/tools/network/__tests__/web-search.test.ts

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../web-search-error.js";
+
 // Mutable mock state - set per test
 let mockWebSearchProvider: string | undefined = "perplexity";
 let mockWebSearchMode: string | undefined = "your-own";
@@ -42,7 +44,9 @@ mock.module("../../../security/secure-keys.js", () => ({
   },
 }));
 
+const realLogger = await import("../../../util/logger.js");
 mock.module("../../../util/logger.js", () => ({
+  ...realLogger,
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
@@ -201,7 +205,8 @@ describe("web_search tool", () => {
 
     const result = await execute({ query: "test" });
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("rate limit exceeded");
+    // Post-retry rate limits surface the friendly recoverable copy (ATL-727).
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
     // 1 initial + 3 retries = 4 calls
     expect(callCount).toBe(4);
   });
@@ -214,7 +219,9 @@ describe("web_search tool", () => {
 
     const result = await execute({ query: "test" });
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("status 500");
+    // 5xx is a backend failure -> friendly recoverable copy, no raw status.
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(result.content).not.toContain("500");
   });
 
   // ---- Brave provider -----------------------------------------------------
@@ -673,7 +680,8 @@ describe("web_search tool", () => {
 
     const result = await execute({ query: "test" });
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("rate limit exceeded");
+    // Post-retry rate limits surface the friendly recoverable copy (ATL-727).
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
     expect(callCount).toBe(4);
   });