@vellumai/assistant 0.11.3 → 0.11.4-staging.2

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

@@ -147,6 +147,11 @@ const { _resetAdapterInstallCacheForTests } =
   await import("../../acp/auto-install.js");
 const { ACP_CLAUDE_OAUTH_MISSING_CODE } =
   await import("../../acp/prepare-agent-env.js");
+const { ACP_CLAUDE_AUTH_REQUIRED_CODE, AcpAuthRequiredError } =
+  await import("../../acp/auth-required.js");
+const { hasAcpConnectCardRaised } =
+  await import("../../acp/acp-connect-card-state.js");
+const { AcpAgentProcess } = await import("../../acp/agent-process.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -547,3 +552,95 @@ describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
     expect(result.errorCode).toBe(ACP_CLAUDE_OAUTH_MISSING_CODE);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Pre-spawn Claude auth rejection
+// ---------------------------------------------------------------------------
+
+describe("pre-spawn Claude auth rejection", () => {
+  test("raises the recovery surface: errorCode, card guidance, registry mark", async () => {
+    // The adapter can reject session creation with auth_required (a stored
+    // credential the server refuses). The error thrown here is produced by
+    // the REAL conversion seam, not hand-built: a wire-shaped JSON-RPC
+    // auth_required rejection driven through AcpAgentProcess.createSession's
+    // actual retry path, so this test fails if that seam stops yielding the
+    // typed error the tool boundary maps to the recovery surface.
+    const proc = new AcpAgentProcess(
+      "claude",
+      { command: "claude-agent-acp", args: [] },
+      (() => ({})) as never,
+    );
+    (proc as unknown as { connection: unknown }).connection = {
+      newSession: () =>
+        Promise.reject({ code: -32000, message: "Authentication required" }),
+    };
+    (proc as unknown as { initializeResponse: unknown }).initializeResponse = {
+      authMethods: [
+        {
+          id: "claude-ai-login",
+          name: "Claude Subscription",
+          type: "terminal",
+        },
+      ],
+    };
+    (proc as unknown as { spawnedEnv: unknown }).spawnedEnv = {};
+    const realSeamError: unknown = await proc.createSession("/tmp").then(
+      () => null,
+      (e: unknown) => e,
+    );
+    expect(realSeamError).toBeInstanceOf(AcpAuthRequiredError);
+
+    spawnMock.mockImplementationOnce(async () => {
+      throw realSeamError;
+    });
+
+    const context = { ...makeContext(), conversationId: "conv-prespawn-auth" };
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      context,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.errorCode).toBe(ACP_CLAUDE_AUTH_REQUIRED_CODE);
+    expect(result.content).toContain("Connect Claude Code");
+    expect(hasAcpConnectCardRaised("conv-prespawn-auth")).toBe(true);
+  });
+
+  test("a raw wire auth_required object (unwrapped initialize path) gets the same surface", async () => {
+    // initialize() cannot ride withAuthRetry (its response advertises the
+    // methods the retry selects from), so its rejection arrives as the plain
+    // JSON-RPC object rather than the typed error. The gate must recognize
+    // both shapes or this path silently flattens to a generic failure.
+    spawnMock.mockImplementationOnce(async () => {
+      throw { code: -32000, message: "Authentication required" };
+    });
+
+    const context = { ...makeContext(), conversationId: "conv-prespawn-raw" };
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      context,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.errorCode).toBe(ACP_CLAUDE_AUTH_REQUIRED_CODE);
+    expect(result.content).toContain("Connect Claude Code");
+    expect(hasAcpConnectCardRaised("conv-prespawn-raw")).toBe(true);
+  });
+
+  test("a non-auth spawn failure keeps the plain flattened result", async () => {
+    spawnMock.mockImplementationOnce(async () => {
+      throw new Error("adapter exploded");
+    });
+
+    const context = { ...makeContext(), conversationId: "conv-prespawn-boom" };
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      context,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.errorCode).toBeUndefined();
+    expect(result.content).toContain("adapter exploded");
+    expect(hasAcpConnectCardRaised("conv-prespawn-boom")).toBe(false);
+  });
+});

package/src/tools/acp/spawn.ts

@@ -3,6 +3,12 @@ import { basename } from "node:path";
 import { z } from "zod";
 
 import { markAcpConnectCardRaised } from "../../acp/acp-connect-card-state.js";
+import {
+  ACP_AUTH_RECOVERY_GUIDANCE,
+  ACP_CLAUDE_AUTH_REQUIRED_CODE,
+  CLAUDE_ACP_COMMAND,
+  isAcpAuthRequired,
+} from "../../acp/auth-required.js";
 import { resolveAgentWithAutoInstall } from "../../acp/auto-install.js";
 import { getAcpSessionManager } from "../../acp/index.js";
 import {
@@ -147,6 +153,32 @@ export async function executeAcpSpawn(
 
     return { content: payload, isError: false };
   } catch (err) {
+    // A pre-spawn rejection of the stored Claude credential (the adapter
+    // raises auth_required during session creation) gets the same recovery
+    // surface as the missing-token preflight: the errorCode raises the inline
+    // Connect card off this failed tool call, the registry mark dedups a
+    // redundant secure prompt, and the guidance keeps the model pointed at
+    // the card. Adapter-gated: the card repairs Claude credentials only.
+    // `isAcpAuthRequired` rather than an instanceof: it also recognizes the
+    // raw JSON-RPC auth_required object, which is how a rejection reaches
+    // this catch from the one protocol call `withAuthRetry` cannot wrap
+    // (`initialize`, whose response is what advertises the auth methods the
+    // retry would need).
+    if (
+      isAcpAuthRequired(err) &&
+      basename(agentConfig.command) === CLAUDE_ACP_COMMAND
+    ) {
+      const message =
+        err instanceof Error
+          ? err.message
+          : String((err as { message?: unknown }).message ?? err);
+      markAcpConnectCardRaised(context.conversationId);
+      return {
+        content: `${message}\n\n${ACP_AUTH_RECOVERY_GUIDANCE}`,
+        isError: true,
+        errorCode: ACP_CLAUDE_AUTH_REQUIRED_CODE,
+      };
+    }
     const msg =
       err instanceof Error
         ? err.message

package/src/tools/document/document-tool.ts

@@ -426,13 +426,22 @@ export function executeDocumentUpdate(
     };
   }
 
+  // The store drops append content that merely restates the document's tail,
+  // so the client renders what actually landed rather than the submission.
+  const applied = result.appliedMarkdown;
+  const message = result.duplicateLeadingContentSkipped
+    ? applied.length === 0
+      ? "Nothing appended: the content is already at the end of the document"
+      : "Document content updated (leading content already at the end of the document was skipped)"
+    : "Document content updated";
+
   // Send document_editor_update message to update the built-in RTE
   if (context.sendToClient) {
     context.sendToClient({
       type: "document_editor_update",
       conversationId: context.conversationId,
       surfaceId,
-      markdown: content,
+      markdown: applied,
       mode,
     });
 
@@ -441,7 +450,7 @@ export function executeDocumentUpdate(
         success: true,
         surface_id: surfaceId,
         mode,
-        message: "Document content updated",
+        message,
       }),
       isError: false,
     };
@@ -458,7 +467,7 @@ export function executeDocumentUpdate(
       success: true,
       surface_id: surfaceId,
       mode,
-      message: "Document content updated (no client connected to render it)",
+      message: `${message} (no client connected to render it)`,
     }),
     isError: false,
   };

package/src/tools/registry.ts

@@ -431,7 +431,8 @@ export function unregisterPluginTools(pluginName: string): void {
  * {@link import("../plugins/mtime-cache.js").getActiveUserPluginTools} and diffs
  * the result into the registry: plugins that vanished are unregistered, new
  * plugins register, and a plugin whose per-tool source mtimes moved is
- * re-registered. Mirrors how hooks resolve through `getUserHookEntriesFor`.
+ * re-registered. Mirrors how hooks resolve through `getUserHookEntriesFor`
+ * in `hooks/registry.ts`.
  *
  * This is a pure read of the plugin cache — it does NOT reconcile the cache
  * against the source-versions sentinel, so it never activates a plugin or runs

package/src/tools/ui-surface/surface-shape-docs.ts

@@ -211,6 +211,17 @@ export const SURFACE_SHAPE_DOCS: Record<string, SurfaceShapeDoc> = {
         ? null
         : '`data.channel` must be one of "slack", "telegram", "phone"',
   },
+  voice_picker: {
+    // The steering lives in `purpose` because that is the only part of a cold
+    // type the model ever sees: `shape` ships solely inside a teaching error,
+    // and an empty payload has no missing-content state to raise one. The
+    // surface exists to replace prose voice tours, so losing the directive
+    // would leave nothing but a renderer nobody invokes.
+    purpose:
+      "inline picker for the voice the assistant speaks in; show it when the user asks to change, hear, or pick a voice rather than describing voices in prose or sending them to Settings; attach no actions and never set await_action; during a live voice call answer in speech instead, the room already carries its own picker",
+    shape:
+      "{}: no payload, the card reads the current voice and the catalog itself. Selecting a voice applies on the assistant's next spoken turn",
+  },
 };
 
 /** Model-facing surface_type enum, derived so docs and schema cannot drift. */

package/src/tools/workflows/run-workflow.ts

@@ -55,8 +55,7 @@ export const runWorkflowInputSchema = z.looseObject({
  */
 function resolveTrustContext(context: ToolContext): TrustContext {
   const conversation = findConversation(context.conversationId);
-  const fromConversation =
-    conversation?.currentTurnTrustContext ?? conversation?.trustContext;
+  const fromConversation = conversation?.getTurnOrRestingTrust();
   if (fromConversation) {
     return fromConversation;
   }

package/src/tts/__tests__/reasoning-tag-filter.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+
+import { createReasoningTagFilter } from "../reasoning-tag-filter.js";
+
+function run(chunks: string[]): string {
+  const filter = createReasoningTagFilter();
+  let out = "";
+  for (const chunk of chunks) {
+    out += filter.push(chunk);
+  }
+  out += filter.flush();
+  return out;
+}
+
+describe("ReasoningTagFilter", () => {
+  test("passes plain text through unchanged", () => {
+    expect(run(["Hello ", "there."])).toBe("Hello there.");
+  });
+
+  test("drops a complete think span within one delta", () => {
+    expect(run(["<think>hm, let me reason</think>Answer."])).toBe("Answer.");
+  });
+
+  test("drops a reasoning span crossing many deltas", () => {
+    expect(
+      run(["<thi", "nk>step one", " step two", "</th", "ink>Spoken reply"]),
+    ).toBe("Spoken reply");
+  });
+
+  test("drops thinking-tag variant and is case-insensitive", () => {
+    expect(run(["<Thinking>inner</Thinking>ok"])).toBe("ok");
+  });
+
+  test("keeps text before and after the span", () => {
+    expect(run(["Sure. <think>secret</think> Done."])).toBe("Sure.  Done.");
+  });
+
+  test("handles multiple spans in one turn", () => {
+    expect(run(["a<think>x</think>b", "<think>y", "z</think>c"])).toBe("abc");
+  });
+
+  test("an unclosed span at end of stream stays dropped", () => {
+    expect(run(["ok<think>never closes"])).toBe("ok");
+  });
+
+  test("a dangling partial open tag is released as literal text at flush", () => {
+    expect(run(["price <th"])).toBe("price <th");
+  });
+
+  test("a false partial that disambiguates to text is released", () => {
+    expect(run(["a <th", "ree-step plan"])).toBe("a <three-step plan");
+  });
+
+  test("does not touch angle brackets that are not think tags", () => {
+    expect(run(["use <b>bold</b> and x < y"])).toBe(
+      "use <b>bold</b> and x < y",
+    );
+  });
+
+  test("holds back nothing across an empty stream", () => {
+    expect(run([""])).toBe("");
+  });
+
+  test("does not shift indexes for characters whose lowercase form is longer", () => {
+    // U+0130 (dotted capital I) lowers to two code units; positional
+    // scanning must never lowercase the haystack wholesale.
+    expect(run(["\u0130stanbul rocks. <think>hidden</think> Done."])).toBe(
+      "\u0130stanbul rocks.  Done.",
+    );
+    expect(run(["\u0130\u0130\u0130<THINK>x</THINK>ok"])).toBe(
+      "\u0130\u0130\u0130ok",
+    );
+  });
+
+  test("prefers the longer tag when both match at one index", () => {
+    expect(run(["a<thinking>x</thinking>b"])).toBe("ab");
+  });
+});

package/src/tts/reasoning-tag-filter.ts

@@ -0,0 +1,89 @@
+/**
+ * Streaming reasoning-tag filter for the TTS pipelines.
+ *
+ * Some OpenAI-compatible reasoning models emit their chain of thought inline
+ * in the content stream as `<think>...</think>` (or `<thinking>...</thinking>`)
+ * spans. When a profile has not opted into the chat-completions provider's
+ * `parseThinkTags` (which re-routes those spans to `thinking_delta`), the raw
+ * reasoning rides `text_delta`, and anything downstream that speaks text
+ * deltas would read the model's inner monologue aloud and delay real speech
+ * by the full length of the reasoning.
+ *
+ * This filter is the TTS-boundary guard: voice output must never speak
+ * reasoning regardless of profile configuration. It is stateful because a
+ * tag or a reasoning span routinely crosses delta boundaries; feed every
+ * delta through {@link ReasoningTagFilter.push} and call
+ * {@link ReasoningTagFilter.flush} when the turn's stream ends.
+ *
+ * Display paths are deliberately untouched: `assistant_text_delta` frames
+ * keep the raw text, exactly like the markdown handling in
+ * `calls/tts-text-sanitizer.ts`.
+ *
+ * Tag scanning lives in `util/think-tag-stream.ts`, shared with the
+ * chat-completions provider's think-tag router, and is positionally exact
+ * on the original string (no full-string lowercasing, which shifts indexes
+ * for characters like the dotted capital I).
+ */
+
+import { indexOfTag, partialTagSuffix } from "../util/think-tag-stream.js";
+
+const OPEN_TAGS = ["<think>", "<thinking>"] as const;
+const CLOSE_TAGS = ["</think>", "</thinking>"] as const;
+
+export class ReasoningTagFilter {
+  private insideReasoning = false;
+  private pending = "";
+
+  /**
+   * Feed one streamed delta; returns the speakable text it releases.
+   * Reasoning spans are dropped; a partial tag at the end of the buffer is
+   * held back until the next delta disambiguates it.
+   */
+  push(text: string): string {
+    this.pending += text;
+    let out = "";
+    for (;;) {
+      if (this.insideReasoning) {
+        const close = indexOfTag(this.pending, CLOSE_TAGS, true);
+        if (close) {
+          this.pending = this.pending.slice(close.index + close.tag.length);
+          this.insideReasoning = false;
+          continue;
+        }
+        // Everything buffered is reasoning except a possible partial close
+        // tag at the end; drop the reasoning, keep the partial.
+        const partial = partialTagSuffix(this.pending, CLOSE_TAGS, true);
+        this.pending = partial > 0 ? this.pending.slice(-partial) : "";
+        return out;
+      }
+      const open = indexOfTag(this.pending, OPEN_TAGS, true);
+      if (open) {
+        out += this.pending.slice(0, open.index);
+        this.pending = this.pending.slice(open.index + open.tag.length);
+        this.insideReasoning = true;
+        continue;
+      }
+      const partial = partialTagSuffix(this.pending, OPEN_TAGS, true);
+      const safeLength = this.pending.length - partial;
+      out += this.pending.slice(0, safeLength);
+      this.pending = partial > 0 ? this.pending.slice(safeLength) : "";
+      return out;
+    }
+  }
+
+  /**
+   * End of stream: release any held-back partial. Outside a reasoning span a
+   * dangling "<thin" was ordinary text after all; inside one, the span never
+   * closed and its content stays dropped.
+   */
+  flush(): string {
+    const rest = this.insideReasoning ? "" : this.pending;
+    this.pending = "";
+    this.insideReasoning = false;
+    return rest;
+  }
+}
+
+export function createReasoningTagFilter(): ReasoningTagFilter {
+  return new ReasoningTagFilter();
+}

package/src/util/think-tag-stream.ts

@@ -0,0 +1,95 @@
+/**
+ * Shared primitives for streaming think-tag scanning.
+ *
+ * Two consumers parse inline `<think>` spans out of streamed model content
+ * and must not drift apart (single source of truth):
+ *
+ * - `providers/openai/chat-completions-provider.ts` ROUTES the spans to
+ *   `thinking_delta` events (content preserved, case-sensitive `<think>`
+ *   only, matching the models that emit it).
+ * - `tts/reasoning-tag-filter.ts` DROPS the spans from the spoken stream
+ *   (case-insensitive, `<think>` and `<thinking>` variants).
+ *
+ * The state machines stay separate because they do different things with
+ * the reasoning; what they share is the tag scanning below. All scanning is
+ * positionally exact on the ORIGINAL string: case-insensitive mode folds
+ * A-Z per character code and never calls `toLowerCase()` on the haystack,
+ * because Unicode lowercasing can change string length (e.g. dotted capital
+ * I, U+0130, lowers to two code units) and shift every subsequent index.
+ * Tags must be given in lowercase ASCII.
+ */
+
+function foldedCharCode(code: number, caseInsensitive: boolean): number {
+  return caseInsensitive && code >= 65 && code <= 90 ? code + 32 : code;
+}
+
+function tagMatchesAt(
+  haystack: string,
+  start: number,
+  tag: string,
+  caseInsensitive: boolean,
+): boolean {
+  if (start + tag.length > haystack.length) {
+    return false;
+  }
+  for (let k = 0; k < tag.length; k += 1) {
+    if (
+      foldedCharCode(haystack.charCodeAt(start + k), caseInsensitive) !==
+      tag.charCodeAt(k)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * First occurrence of any tag in `haystack`, by original-string index.
+ * When several tags match at the same index the longest wins, so
+ * `<thinking>` is not consumed as `<think>` plus stray text.
+ */
+export function indexOfTag(
+  haystack: string,
+  tags: readonly string[],
+  caseInsensitive: boolean,
+): { index: number; tag: string } | null {
+  for (let i = 0; i < haystack.length; i += 1) {
+    let bestTag: string | null = null;
+    for (const tag of tags) {
+      if (tagMatchesAt(haystack, i, tag, caseInsensitive)) {
+        if (bestTag === null || tag.length > bestTag.length) {
+          bestTag = tag;
+        }
+      }
+    }
+    if (bestTag !== null) {
+      return { index: i, tag: bestTag };
+    }
+  }
+  return null;
+}
+
+/**
+ * Length of the longest suffix of `text` that is a proper prefix of any
+ * listed tag. Streaming scanners hold that many characters back so a tag
+ * split across deltas is not emitted before it can be recognized.
+ */
+export function partialTagSuffix(
+  text: string,
+  tags: readonly string[],
+  caseInsensitive: boolean,
+): number {
+  const longest = Math.max(...tags.map((tag) => tag.length)) - 1;
+  for (let len = Math.min(text.length, longest); len > 0; len -= 1) {
+    const start = text.length - len;
+    for (const tag of tags) {
+      if (
+        len < tag.length &&
+        tagMatchesAt(text, start, tag.slice(0, len), caseInsensitive)
+      ) {
+        return len;
+      }
+    }
+  }
+  return 0;
+}