@vellumai/assistant 0.4.48 → 0.4.49

package/src/__tests__/trust-store.test.ts

@@ -778,7 +778,6 @@ describe("Trust Store", () => {
         "computer_use_drag",
         "computer_use_key",
         "computer_use_open_app",
-        "computer_use_request_control",
         "computer_use_run_applescript",
         "computer_use_scroll",
         "computer_use_type_text",
@@ -901,22 +900,6 @@ describe("Trust Store", () => {
       );
     });
 
-    test("findHighestPriorityRule matches default ask for computer_use_request_control", () => {
-      const match = findHighestPriorityRule(
-        "computer_use_request_control",
-        ["computer_use_request_control:"],
-        "/tmp",
-      );
-      expect(match).not.toBeNull();
-      expect(match!.id).toBe("default:ask-computer_use_request_control-global");
-      expect(match!.decision).toBe("ask");
-      expect(match!.priority).toBe(
-        DEFAULT_PRIORITY_BY_ID.get(
-          "default:ask-computer_use_request_control-global",
-        )!,
-      );
-    });
-
     test("bootstrap delete rule matches only when workingDir is the workspace dir", () => {
       const workspaceDir = join(testDir, "workspace");
       // Should match when workingDir is the workspace directory — the bootstrap
@@ -1755,11 +1738,7 @@ describe("computer-use tool trust rule matching", () => {
   test("actionable CU tools have default ask trust rules", () => {
     // Actionable CU tools (those that perform screen interactions) should
     // have default "ask" rules so strict mode prompts before use.
-    const actionableCuTools = [
-      "computer_use_click",
-      "computer_use_type_text",
-      "computer_use_request_control",
-    ];
+    const actionableCuTools = ["computer_use_click", "computer_use_type_text"];
 
     for (const name of actionableCuTools) {
       const rule = findHighestPriorityRule(name, [name], "/tmp/test");

package/src/__tests__/trusted-contact-approval-notifier.test.ts

@@ -42,7 +42,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/trusted-contact-inline-approval-integration.test.ts

@@ -45,7 +45,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/twilio-routes.test.ts

@@ -77,7 +77,6 @@ function resolveIngressBaseUrlFromConfig(ingressConfig: unknown): string {
 
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
-  getCallWelcomeGreeting: () => process.env.CALL_WELCOME_GREETING || undefined,
   getGatewayInternalBaseUrl: () => "http://gateway.internal:7830",
   getIngressPublicBaseUrl: () => mockIngressPublicBaseUrl,
   setIngressPublicBaseUrl: (value: string | undefined) => {
@@ -109,13 +108,11 @@ mock.module("../util/logger.js", () => ({
     debug: () => {},
     trace: () => {},
     fatal: () => {},
-    isDebug: () => false,
     child: () => ({
       info: () => {},
       warn: () => {},
       error: () => {},
       debug: () => {},
-      isDebug: () => false,
     }),
   }),
 }));
@@ -438,7 +435,6 @@ describe("twilio webhook routes", () => {
     updatePhoneNumberWebhookCalls = [];
     mockTwilioApiValidationStatus = 200;
     mockTwilioApiValidationBody = JSON.stringify({ sid: "AC_validated" });
-    delete process.env.CALL_WELCOME_GREETING;
 
     globalThis.fetch = (async (
       url: string | URL | Request,
@@ -819,18 +815,6 @@ describe("twilio webhook routes", () => {
       const twiml = await res.text();
       expect(twiml).not.toContain("welcomeGreeting=");
     });
-
-    test("TwiML includes explicit welcome greeting override when configured", async () => {
-      process.env.CALL_WELCOME_GREETING = "Custom transport greeting";
-      const session = createTestSession("conv-twiml-4", "CA_twiml_4");
-      const req = makeVoiceRequest(session.id, { CallSid: "CA_twiml_4" });
-
-      const res = await handleVoiceWebhook(req);
-
-      expect(res.status).toBe(200);
-      const twiml = await res.text();
-      expect(twiml).toContain('welcomeGreeting="Custom transport greeting"');
-    });
   });
 
   // ── Handler-level idempotency concurrency tests ─────────────────

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -64,7 +64,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/voice-scoped-grant-consumer.test.ts

@@ -44,7 +44,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/agent/ax-tree-compaction.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, test } from "bun:test";
+
+import type { Message } from "../providers/types.js";
+import { compactAxTreeHistory, escapeAxTreeContent } from "./loop.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Build a user message with a single tool_result containing an AX tree. */
+function axTreeToolResult(id: string, axContent: string): Message {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: id,
+        content: `Some preamble\n<ax-tree>\n${axContent}\n</ax-tree>`,
+        is_error: false,
+      },
+    ],
+  };
+}
+
+/** Build an assistant message (no tool use). */
+function assistantText(text: string): Message {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }],
+  };
+}
+
+/** Build a user message without AX tree content. */
+function userText(text: string): Message {
+  return {
+    role: "user",
+    content: [{ type: "text", text }],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// compactAxTreeHistory
+// ---------------------------------------------------------------------------
+
+describe("compactAxTreeHistory", () => {
+  test("returns messages unchanged when fewer than MAX_AX_TREES_IN_HISTORY AX trees", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+    ];
+    const result = compactAxTreeHistory(messages);
+    expect(result).toBe(messages); // same reference — no copy
+  });
+
+  test("returns messages unchanged when exactly MAX_AX_TREES_IN_HISTORY AX trees", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+    ];
+    const result = compactAxTreeHistory(messages);
+    expect(result).toBe(messages);
+  });
+
+  test("strips oldest AX trees, keeps only last 2 from 5", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+      assistantText("ok"),
+      axTreeToolResult("t3", "tree-3"),
+      assistantText("ok"),
+      axTreeToolResult("t4", "tree-4"),
+      assistantText("ok"),
+      axTreeToolResult("t5", "tree-5"),
+    ];
+
+    const result = compactAxTreeHistory(messages);
+
+    // Messages at indices 0, 2, 4 should have AX trees stripped (t1, t2, t3)
+    for (const idx of [0, 2, 4]) {
+      const block = result[idx].content[0];
+      expect(block.type).toBe("tool_result");
+      if (block.type === "tool_result") {
+        expect(block.content).not.toContain("<ax-tree>");
+        expect(block.content).toContain("<ax_tree_omitted />");
+      }
+    }
+
+    // Messages at indices 6, 8 should still have AX trees (t4, t5)
+    for (const idx of [6, 8]) {
+      const block = result[idx].content[0];
+      expect(block.type).toBe("tool_result");
+      if (block.type === "tool_result") {
+        expect(block.content).toContain("<ax-tree>");
+        expect(block.content).not.toContain("<ax_tree_omitted />");
+      }
+    }
+  });
+
+  test("does not modify assistant messages", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+      assistantText("response with <ax-tree>fake</ax-tree>"),
+      axTreeToolResult("t3", "tree-3"),
+    ];
+
+    const result = compactAxTreeHistory(messages);
+
+    // Assistant message should be unchanged
+    const assistantMsg = result[3];
+    expect(assistantMsg.content[0].type).toBe("text");
+    if (assistantMsg.content[0].type === "text") {
+      expect(assistantMsg.content[0].text).toContain("<ax-tree>");
+    }
+  });
+
+  test("does not modify user messages without tool_result blocks", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+      assistantText("ok"),
+      userText("Please help"),
+      axTreeToolResult("t3", "tree-3"),
+    ];
+
+    const result = compactAxTreeHistory(messages);
+
+    // The plain user text message should be untouched
+    expect(result[4]).toBe(messages[4]);
+  });
+
+  test("preserves non-AX-tree tool_result blocks in stripped messages", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t1",
+            content: "normal result without ax tree",
+            is_error: false,
+          },
+          {
+            type: "tool_result",
+            tool_use_id: "t1-ax",
+            content: "<ax-tree>\ntree-1\n</ax-tree>",
+            is_error: false,
+          },
+        ],
+      },
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+      assistantText("ok"),
+      axTreeToolResult("t3", "tree-3"),
+    ];
+
+    const result = compactAxTreeHistory(messages);
+
+    // First message should have the AX tree stripped but normal result preserved
+    const firstMsg = result[0];
+    const normalBlock = firstMsg.content[0];
+    expect(normalBlock.type).toBe("tool_result");
+    if (normalBlock.type === "tool_result") {
+      expect(normalBlock.content).toBe("normal result without ax tree");
+    }
+
+    const axBlock = firstMsg.content[1];
+    expect(axBlock.type).toBe("tool_result");
+    if (axBlock.type === "tool_result") {
+      expect(axBlock.content).toContain("<ax_tree_omitted />");
+      expect(axBlock.content).not.toContain("<ax-tree>");
+    }
+  });
+
+  test("returns empty array for empty input", () => {
+    const result = compactAxTreeHistory([]);
+    expect(result).toEqual([]);
+  });
+
+  test("is pure — does not mutate input messages", () => {
+    const messages: Message[] = [
+      axTreeToolResult("t1", "tree-1"),
+      assistantText("ok"),
+      axTreeToolResult("t2", "tree-2"),
+      assistantText("ok"),
+      axTreeToolResult("t3", "tree-3"),
+    ];
+
+    // Deep copy to compare later
+    const originalContent = messages[0].content[0];
+    const originalText =
+      originalContent.type === "tool_result" ? originalContent.content : "";
+
+    compactAxTreeHistory(messages);
+
+    // Original message should be unchanged
+    const afterContent = messages[0].content[0];
+    const afterText =
+      afterContent.type === "tool_result" ? afterContent.content : "";
+    expect(afterText).toBe(originalText);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// escapeAxTreeContent
+// ---------------------------------------------------------------------------
+
+describe("escapeAxTreeContent", () => {
+  test("escapes literal </ax-tree> inside content", () => {
+    const input = "Some XML: <div></ax-tree></div>";
+    const result = escapeAxTreeContent(input);
+    expect(result).toBe("Some XML: <div>&lt;/ax-tree&gt;</div>");
+  });
+
+  test("handles case-insensitive matches", () => {
+    const input = "</AX-TREE> and </Ax-Tree>";
+    const result = escapeAxTreeContent(input);
+    expect(result).toBe("&lt;/ax-tree&gt; and &lt;/ax-tree&gt;");
+  });
+
+  test("returns content unchanged when no closing tags present", () => {
+    const input = "Normal AX tree content with <ax-tree> opening tag";
+    const result = escapeAxTreeContent(input);
+    expect(result).toBe(input);
+  });
+
+  test("handles empty string", () => {
+    expect(escapeAxTreeContent("")).toBe("");
+  });
+});

package/src/agent/loop.ts

@@ -14,7 +14,7 @@ import {
   applyStreamingSubstitution,
   applySubstitutions,
 } from "../tools/sensitive-output-placeholders.js";
-import { getLogger, isDebug, truncateForLog } from "../util/logger.js";
+import { getLogger } from "../util/logger.js";
 
 const log = getLogger("agent-loop");
 
@@ -179,7 +179,6 @@ export class AgentLoop {
     let toolUseTurns = 0;
     let nudgedForEmptyResponse = false;
     let lastLlmCallTime = 0;
-    const debug = isDebug();
     const rlog = requestId ? log.child({ requestId }) : log;
 
     // Per-run substitution map for sensitive output placeholders.
@@ -191,7 +190,6 @@ export class AgentLoop {
     while (true) {
       if (signal?.aborted) break;
 
-      const turnStart = Date.now();
       let toolUseBlocks: Extract<ContentBlock, { type: "tool_use" }>[] = [];
 
       try {
@@ -227,22 +225,6 @@ export class AgentLoop {
           providerConfig.tool_choice = this.config.toolChoice;
         }
 
-        if (debug) {
-          rlog.debug(
-            {
-              systemPrompt: truncateForLog(turnSystemPrompt, 200),
-              messageCount: history.length,
-              lastMessage:
-                history.length > 0
-                  ? summarizeMessage(history[history.length - 1])
-                  : null,
-              toolCount: currentTools.length,
-              config: providerConfig,
-            },
-            "Sending request to provider",
-          );
-        }
-
         const preLlmResult = await getHookManager().trigger("pre-llm-call", {
           systemPrompt: turnSystemPrompt,
           messages: history,
@@ -275,7 +257,11 @@ export class AgentLoop {
         // screenshots from accumulating in the context window. The LLM
         // already saw each image on the turn it was captured; keeping
         // base64 blobs in history rapidly exhausts the context budget.
-        const providerHistory = stripOldImageBlocks(history);
+        // Also strip old AX tree snapshots to keep TTFT from growing
+        // linearly with step count in computer-use sessions.
+        const providerHistory = compactAxTreeHistory(
+          stripOldImageBlocks(history),
+        );
 
         const response = await this.provider.sendMessage(
           providerHistory,
@@ -328,33 +314,6 @@ export class AgentLoop {
 
         const providerDurationMs = Date.now() - providerStart;
 
-        if (debug) {
-          rlog.debug(
-            {
-              providerDurationMs,
-              model: response.model,
-              stopReason: response.stopReason,
-              inputTokens: response.usage.inputTokens,
-              outputTokens: response.usage.outputTokens,
-              cacheCreationInputTokens: response.usage.cacheCreationInputTokens,
-              cacheReadInputTokens: response.usage.cacheReadInputTokens,
-              contentBlocks: response.content.map((b) => ({
-                type: b.type,
-                ...(b.type === "text"
-                  ? { text: truncateForLog(b.text, 1200) }
-                  : {}),
-                ...(b.type === "tool_use"
-                  ? {
-                      name: b.name,
-                      input: truncateForLog(JSON.stringify(b.input), 1200),
-                    }
-                  : {}),
-              })),
-            },
-            "Provider response received",
-          );
-        }
-
         onEvent({
           type: "usage",
           inputTokens: response.usage.inputTokens,
@@ -443,16 +402,6 @@ export class AgentLoop {
             name: toolUse.name,
             input: toolUse.input,
           });
-
-          if (debug) {
-            rlog.debug(
-              {
-                tool: toolUse.name,
-                input: truncateForLog(JSON.stringify(toolUse.input), 300),
-              },
-              "Executing tool",
-            );
-          }
         }
 
         // If already cancelled, synthesize cancelled results and stop
@@ -469,49 +418,11 @@ export class AgentLoop {
           break;
         }
 
-        // Guard against dual-control-mode conflicts in a single turn.
-        // If the model escalates to foreground computer control, browser_* tools
-        // in the same response create competing browser sessions/windows and can
-        // thrash renderer CPU. Reject browser_* calls in that turn.
-        const hasComputerUseEscalation = toolUseBlocks.some(
-          (toolUse) => toolUse.name === "computer_use_request_control",
-        );
-        const blockedBrowserToolIds = hasComputerUseEscalation
-          ? new Set(
-              toolUseBlocks
-                .filter((toolUse) => toolUse.name.startsWith("browser_"))
-                .map((toolUse) => toolUse.id),
-            )
-          : new Set<string>();
-
-        if (blockedBrowserToolIds.size > 0) {
-          log.warn(
-            {
-              blockedBrowserToolCount: blockedBrowserToolIds.size,
-              toolNames: toolUseBlocks.map((toolUse) => toolUse.name),
-            },
-            "Blocking browser_* tools: computer_use_request_control was requested in same turn",
-          );
-        }
-
         // Execute all tools concurrently for reduced latency.
         // Race against the abort signal so cancellation isn't blocked by
         // stuck tools (e.g. a hung browser navigation).
         const toolExecutionPromise = Promise.all(
           toolUseBlocks.map(async (toolUse) => {
-            const toolStart = Date.now();
-
-            if (blockedBrowserToolIds.has(toolUse.id)) {
-              return {
-                toolUse,
-                result: {
-                  content:
-                    "Error: browser_* tools cannot run in the same turn as computer_use_request_control. Continue using the foreground computer-use session only.",
-                  isError: true,
-                },
-              };
-            }
-
             const result = await this.toolExecutor!(
               toolUse.name,
               toolUse.input,
@@ -525,20 +436,6 @@ export class AgentLoop {
               toolUse.id,
             );
 
-            const toolDurationMs = Date.now() - toolStart;
-
-            if (debug) {
-              rlog.debug(
-                {
-                  tool: toolUse.name,
-                  toolDurationMs,
-                  isError: result.isError,
-                  output: truncateForLog(result.content, 300),
-                },
-                "Tool execution complete",
-              );
-            }
-
             return { toolUse, result };
           }),
         );
@@ -658,19 +555,6 @@ export class AgentLoop {
         // Add tool results as a user message and continue the loop
         history.push({ role: "user", content: resultBlocks });
 
-        if (debug) {
-          const turnDurationMs = Date.now() - turnStart;
-          rlog.debug(
-            {
-              turnDurationMs,
-              providerDurationMs,
-              toolCount: toolUseBlocks.length,
-              turn: toolUseTurns,
-            },
-            "Turn complete",
-          );
-        }
-
         // Invoke checkpoint callback after tool results are in history
         if (onCheckpoint) {
           const decision = onCheckpoint({
@@ -715,14 +599,76 @@ export class AgentLoop {
   }
 }
 
-function summarizeMessage(msg: Message): {
-  role: string;
-  blockTypes: string[];
-} {
-  return {
-    role: msg.role,
-    blockTypes: msg.content.map((b) => b.type),
-  };
+/** Number of most-recent AX tree snapshots to keep in conversation history. */
+const MAX_AX_TREES_IN_HISTORY = 2;
+
+/** Regex that matches the `<ax-tree>...</ax-tree>` markers. */
+const AX_TREE_PATTERN = /<ax-tree>[\s\S]*?<\/ax-tree>/g;
+const AX_TREE_PLACEHOLDER = "<ax_tree_omitted />";
+
+/**
+ * Escapes any literal `</ax-tree>` occurrences inside AX tree content so
+ * that the non-greedy compaction regex (`AX_TREE_PATTERN`) does not stop
+ * prematurely when the user happens to be viewing XML/HTML source that
+ * contains the closing tag.  The escaped content does not need to be
+ * unescaped because compaction replaces the entire block with a placeholder.
+ */
+export function escapeAxTreeContent(content: string): string {
+  return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");
+}
+
+/**
+ * Returns a shallow copy of `messages` where all but the most recent
+ * `MAX_AX_TREES_IN_HISTORY` `<ax-tree>` blocks have been replaced with a
+ * short placeholder.  This keeps the conversation context small so that
+ * TTFT does not grow linearly with step count in computer-use sessions.
+ */
+export function compactAxTreeHistory(messages: Message[]): Message[] {
+  // Collect indices of user messages that contain an <ax-tree> block
+  const indicesWithAxTree: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user") continue;
+    for (const block of msg.content) {
+      if (
+        block.type === "tool_result" &&
+        typeof block.content === "string" &&
+        block.content.includes("<ax-tree>")
+      ) {
+        indicesWithAxTree.push(i);
+        break;
+      }
+    }
+  }
+
+  if (indicesWithAxTree.length <= MAX_AX_TREES_IN_HISTORY) {
+    return messages;
+  }
+
+  const toStrip = new Set(indicesWithAxTree.slice(0, -MAX_AX_TREES_IN_HISTORY));
+
+  return messages.map((msg, idx) => {
+    if (!toStrip.has(idx)) return msg;
+    return {
+      ...msg,
+      content: msg.content.map((block) => {
+        if (
+          block.type === "tool_result" &&
+          typeof block.content === "string" &&
+          block.content.includes("<ax-tree>")
+        ) {
+          return {
+            ...block,
+            content: block.content.replace(
+              AX_TREE_PATTERN,
+              AX_TREE_PLACEHOLDER,
+            ),
+          };
+        }
+        return block;
+      }),
+    };
+  });
 }
 
 /**

package/src/calls/call-domain.ts

@@ -5,7 +5,6 @@
  * to these functions so business logic lives in one place.
  */
 
-import { getTwilioUserPhoneNumber } from "../config/env.js";
 import { loadConfig } from "../config/loader.js";
 import { VALID_CALLER_IDENTITY_MODES } from "../config/schema.js";
 import type { AssistantConfig } from "../config/types.js";
@@ -111,8 +110,7 @@ export type CallerIdentitySource =
   | "per_call_override"
   | "implicit_default"
   | "user_config"
-  | "secure_key"
-  | "env_var";
+  | "secure_key";
 
 export type CallerIdentityResult =
   | {
@@ -194,9 +192,6 @@ export async function resolveCallerIdentity(
   if (identityConfig.userNumber) {
     userNumber = identityConfig.userNumber;
     numberSource = "user_config";
-  } else if (getTwilioUserPhoneNumber()) {
-    userNumber = getTwilioUserPhoneNumber()!;
-    numberSource = "env_var";
   } else {
     const secureKeyValue = getSecureKey(
       credentialKey("twilio", "user_phone_number"),