@vellumai/assistant 0.8.12 → 0.9.0-staging.1

package/src/__tests__/max-tokens-continue-hook.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for the default `max-tokens-continue` plugin's hooks.
+ *
+ * Covers:
+ * - The `post-model-call` hook's decision for the canonical cases: a
+ *   main-agent turn truncated at the output token limit → continue, with the
+ *   truncated turn and the canonical continuation nudge appended to
+ *   `messages`; any other stop reason → stop; non-main-agent call sites →
+ *   stop; a provider rejection → stop; an entirely-stripped (empty) truncated
+ *   turn → stop.
+ * - The per-run budget is split across the two hooks: `post-model-call`
+ *   consumes one unit per continue (up to `MAX_TOKENS_AUTO_CONTINUES`) and
+ *   the `stop` hook clears the counter on the definitive terminal so the next
+ *   run starts with a full budget.
+ *
+ * The loop's actual side-effects (keeping the partial turn, per-run backstop,
+ * the continuation card on a terminal stop) live in `agent/loop.ts`. This
+ * file isolates the hook.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type {
+  PluginLogger,
+  PostModelCallContext,
+  StopContext,
+} from "../plugin-api/types.js";
+import {
+  hasMaxTokensContinueBudget,
+  MAX_TOKENS_AUTO_CONTINUES,
+  resetMaxTokensContinueStoreForTests,
+} from "../plugins/defaults/max-tokens-continue/continue-state-store.js";
+import postModelCall, {
+  MAX_TOKENS_CONTINUE_NUDGE_TEXT,
+} from "../plugins/defaults/max-tokens-continue/hooks/post-model-call.js";
+import stop from "../plugins/defaults/max-tokens-continue/hooks/stop.js";
+import type { ContentBlock } from "../providers/types.js";
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+const truncatedText: ContentBlock = {
+  type: "text",
+  text: "Here is the start of a very long answer that got cut o",
+};
+
+function makeCtx(
+  overrides: Partial<PostModelCallContext> = {},
+): PostModelCallContext {
+  return {
+    conversationId: "conv-mtc",
+    callSite: "mainAgent",
+    content: [truncatedText],
+    messages: [{ role: "user", content: [{ type: "text", text: "build it" }] }],
+    stopReason: "max_tokens",
+    decision: "stop",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  resetMaxTokensContinueStoreForTests();
+});
+
+// ─── Decisions ───────────────────────────────────────────────────────────────
+
+describe("max-tokens-continue post-model-call hook", () => {
+  test("truncated main-agent turn → continue with the turn and nudge appended", async () => {
+    /**
+     * Tests that a max_tokens stop on a main-agent turn auto-continues.
+     */
+    // GIVEN a main-agent turn that stopped at the output token limit.
+    const ctx = makeCtx();
+    const priorLength = ctx.messages.length;
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it asks the loop to continue.
+    expect(ctx.decision).toBe("continue");
+    // AND it appends the truncated assistant turn followed by the nudge.
+    expect(ctx.messages).toHaveLength(priorLength + 2);
+    expect(ctx.messages[priorLength]).toEqual({
+      role: "assistant",
+      content: [truncatedText],
+    });
+    expect(ctx.messages[priorLength + 1]).toEqual({
+      role: "user",
+      content: [{ type: "text", text: MAX_TOKENS_CONTINUE_NUDGE_TEXT }],
+    });
+  });
+
+  test("non-max-tokens stop reason → stop", async () => {
+    /**
+     * Tests that ordinary stop reasons are left alone.
+     */
+    // GIVEN a turn that ended normally.
+    const ctx = makeCtx({ stopReason: "end_turn" });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop and messages are untouched.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("non-mainAgent call site → stop", async () => {
+    /**
+     * Tests that background/subagent calls are never auto-continued.
+     */
+    // GIVEN a truncated turn on a non-main-agent call site.
+    const ctx = makeCtx({ callSite: "recall" });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("provider rejection → stop", async () => {
+    /**
+     * Tests that a rejection outcome (no reply content) is ignored.
+     */
+    // GIVEN a provider rejection carrying an error.
+    const ctx = makeCtx({ error: new Error("boom"), content: [] });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("empty truncated content → stop", async () => {
+    /**
+     * Tests that a turn with nothing left after truncation-block stripping
+     * ends terminally rather than pushing an empty assistant message.
+     */
+    // GIVEN a max_tokens stop whose safe content is empty.
+    const ctx = makeCtx({ content: [] });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the decision stays stop and nothing is appended.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toHaveLength(1);
+  });
+
+  test("budget exhausts after MAX_TOKENS_AUTO_CONTINUES and stop hook resets it", async () => {
+    /**
+     * Tests the per-run continue budget and its reset on the terminal stop.
+     */
+    // GIVEN the budget is consumed by repeated truncated turns.
+    for (let i = 0; i < MAX_TOKENS_AUTO_CONTINUES; i++) {
+      const ctx = makeCtx();
+      await postModelCall(ctx);
+      expect(ctx.decision).toBe("continue");
+    }
+    expect(hasMaxTokensContinueBudget("conv-mtc")).toBe(false);
+
+    // WHEN one more truncated turn arrives.
+    const exhausted = makeCtx();
+    await postModelCall(exhausted);
+
+    // THEN the hook lets the turn end.
+    expect(exhausted.decision).toBe("stop");
+    expect(exhausted.messages).toHaveLength(1);
+
+    // AND the stop hook clears the budget so the next run continues afresh.
+    await stop({ conversationId: "conv-mtc" } as StopContext);
+    expect(hasMaxTokensContinueBudget("conv-mtc")).toBe(true);
+  });
+});

package/src/__tests__/media-generate-image.test.ts

@@ -322,7 +322,13 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock Gemini error: API failure");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Failed model: gemini-3.1-flash-image-preview",
+    );
+    expect(result.content).toContain(
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
+    );
+    expect(result.content).toContain(
+      "Retrying this call once with a different model parameter is allowed",
     );
   });
 
@@ -335,7 +341,10 @@ describe("image-studio skill script wrapper", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock OpenAI error: openai failure");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
+    );
+    expect(result.content).toContain(
+      "Retrying this call once with a different model parameter is allowed",
     );
   });
 
@@ -346,8 +355,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("No Gemini API key");
+    expect(result.content).toContain("Report this error to the user as-is");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
     );
   });
 
@@ -359,8 +369,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain("Report this error to the user as-is");
     expect(result.content).toContain(
-      "Do not change service configuration (mode, provider, or model) to try to fix it",
+      "Do not change service configuration (managed/your-own mode or default provider/model settings)",
     );
   });
 
@@ -463,11 +474,11 @@ describe("image-studio TOOLS.json manifest", () => {
     expect(props.mode.enum).toEqual(["generate", "edit"]);
     expect(props.source_paths.type).toBe("array");
     expect(props.attachment_ids).toBeUndefined();
-    expect(props.model.enum).toEqual([
-      "gemini-3.1-flash-image-preview",
-      "gemini-3-pro-image-preview",
-      "gpt-image-2",
-    ]);
+    // No enum by design: model accepts tier aliases or concrete IDs, and is
+    // validated at runtime against the registry so the schema never goes
+    // stale when models change.
+    expect(props.model.type).toBe("string");
+    expect(props.model.enum).toBeUndefined();
     expect(props.variants.type).toBe("number");
   });
 });

package/src/__tests__/model-intents.test.ts

@@ -20,7 +20,7 @@ describe("model intents", () => {
       "claude-haiku-4-5-20251001",
     );
     expect(resolveModelIntent("anthropic", "quality-optimized")).toBe(
-      "claude-fable-5",
+      "claude-opus-4-8",
     );
     expect(resolveModelIntent("anthropic", "vision-optimized")).toBe(
       "claude-opus-4-6",

package/src/__tests__/normalize-onboarding.test.ts

@@ -139,6 +139,32 @@ describe("normalizeOnboardingContext", () => {
     expect(result.preferredName).toBeUndefined();
   });
 
+  test("maps occupation through, trimmed", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      occupation: "  Software Engineer  ",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.occupation).toBe("Software Engineer");
+  });
+
+  test("absent or blank occupation yields undefined", () => {
+    expect(
+      normalizeOnboardingContext({ tools: [], tasks: [], tone: "friendly" })
+        .occupation,
+    ).toBeUndefined();
+    expect(
+      normalizeOnboardingContext({
+        tools: [],
+        tasks: [],
+        tone: "friendly",
+        occupation: "   ",
+      }).occupation,
+    ).toBeUndefined();
+  });
+
   test("tone passes through", () => {
     const ctx: OnboardingContext = {
       tools: [],

package/src/__tests__/notification-decision-strategy.test.ts

@@ -15,8 +15,6 @@ import {
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
-  sanitizeIdentityField,
-  sanitizeMessagePreview,
 } from "../notifications/access-request-copy.js";
 import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import { composeFallbackCopy } from "../notifications/copy-composer.js";
@@ -24,6 +22,10 @@ import {
   enforceGuardianCallConversationAffinity,
   validateConversationActions,
 } from "../notifications/decision-engine.js";
+import {
+  sanitizeIdentityField,
+  sanitizeMessagePreview,
+} from "../notifications/notification-utils.js";
 import type { NotificationSignal } from "../notifications/signal.js";
 import type {
   NotificationChannel,

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -186,9 +186,18 @@ describe("TelegramAdapter", () => {
       contextPayload: {
         requestId: "req-abc-123",
         requestCode: "XYZW",
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
       },
+      approvalContext: {
+        requestId: "req-abc-123",
+        actions: [
+          { id: "approve_once", label: "Approve once" },
+          { id: "reject", label: "Reject" },
+        ],
+        plainTextFallback:
+          'TestUser is requesting access to the assistant.\nReply "XYZW approve" to grant access or "XYZW reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+      },
     });
 
     const result = await adapter.send(payload, makeDestination());
@@ -237,7 +246,7 @@ describe("TelegramAdapter", () => {
         body: "Someone is requesting access.",
       },
       contextPayload: {
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
         // no requestId
       },
@@ -264,9 +273,18 @@ describe("TelegramAdapter", () => {
       contextPayload: {
         requestId: "req-abc-123",
         requestCode: "XYZW",
-        senderIdentifier: "Marina",
+        senderIdentifier: "TestUser",
         sourceChannel: "telegram",
       },
+      approvalContext: {
+        requestId: "req-abc-123",
+        actions: [
+          { id: "approve_once", label: "Approve once" },
+          { id: "reject", label: "Reject" },
+        ],
+        plainTextFallback:
+          'TestUser is requesting access to the assistant.\nReply "XYZW approve" to grant access or "XYZW reject" to deny.\nReply "open invite flow" to start Trusted Contacts invite flow.',
+      },
     });
 
     const result = await adapter.send(payload, makeDestination());

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -102,6 +102,28 @@ describe("pendingInteractions.resolve emits interaction_resolved", () => {
     expect(publishedMessages).toHaveLength(0);
   });
 
+  test("no event is emitted for a conversation-less interaction", () => {
+    /**
+     * Conversation-less interactions (e.g. the CLI `credentials prompt`
+     * command) resolve through their own resolver rather than a conversation.
+     * The `interaction_resolved` envelope requires a conversationId, so the
+     * tracker skips the broadcast instead of emitting an invalid event.
+     */
+    // GIVEN a registered interaction with no owning conversation
+    pendingInteractions.register("req-detached", { kind: "secret" });
+
+    // WHEN it is resolved
+    const returned = pendingInteractions.resolve("req-detached", "answered");
+
+    // THEN the entry is still returned to its caller
+    expect(returned).toBeDefined();
+
+    // AND no interaction_resolved envelope is published
+    expect(
+      publishedMessages.filter((m) => m.type === "interaction_resolved"),
+    ).toHaveLength(0);
+  });
+
   test("a single resolve emits exactly one event", () => {
     pendingInteractions.register("req-once", {
       conversationId: "conv-e",
@@ -186,4 +208,44 @@ describe("removeByConversation emits interaction_resolved per entry", () => {
         .state,
     ).toBe("cancelled");
   });
+
+  test("settles a swept secret prompt's resolver with a cancelled result", () => {
+    /**
+     * A secret prompt blocks its caller (the CLI `credentials prompt` command
+     * or the in-conversation SecretPrompter) on `rpcResolve`. Unlike questions
+     * (abort-signal teardown) and confirmations (denyAllPendingConfirmations),
+     * nothing else settles a secret when it is superseded, so removing the
+     * entry alone would hang the caller until its IPC client times out.
+     */
+    // GIVEN a pending secret whose caller is blocked on rpcResolve
+    const resolved: unknown[] = [];
+    pendingInteractions.register("secret-sweep", {
+      conversationId: "conv-sweep",
+      kind: "secret",
+      rpcResolve: (value) => resolved.push(value),
+    });
+
+    // WHEN a new user message supersedes the conversation's interactions
+    pendingInteractions.removeByConversation("conv-sweep");
+
+    // THEN the secret resolver is settled once with a cancelled result
+    expect(resolved).toEqual([{ value: null, delivery: "store" }]);
+  });
+
+  test("does not invoke a swept confirmation's resolver with a secret result", () => {
+    // GIVEN a pending confirmation carrying an rpcResolve callback
+    const resolved: unknown[] = [];
+    pendingInteractions.register("conf-sweep", {
+      conversationId: "conv-conf",
+      kind: "confirmation",
+      rpcResolve: (value) => resolved.push(value),
+    });
+
+    // WHEN the conversation is superseded
+    pendingInteractions.removeByConversation("conv-conf");
+
+    // THEN the confirmation resolver is left untouched — only secret prompts
+    // are settled with a SecretPromptResult-shaped value here.
+    expect(resolved).toHaveLength(0);
+  });
 });

package/src/__tests__/post-turn-tool-result-truncation.test.ts

@@ -49,8 +49,10 @@ describe("postTurnTruncateToolResults", () => {
     const shortContent = "a".repeat(THRESHOLD_CHARS);
     const messages = makeMessages([makeToolResult(shortContent)]);
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(0);
     expect(result).toBe(messages); // same reference — no copy
@@ -62,12 +64,17 @@ describe("postTurnTruncateToolResults", () => {
     const toolUseId = "tool_use_abc";
     const messages = makeMessages([makeToolResult(longContent, toolUseId)]);
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(1);
 
-    const block = result[0].content[0] as { type: "tool_result"; content: string };
+    const block = result[0].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
     expect(block.content).toContain(TRUNCATION_MARKER);
     expect(block.content.length).toBeLessThan(longContent.length);
 
@@ -83,8 +90,10 @@ describe("postTurnTruncateToolResults", () => {
       makeToolResult(longContent, "tool_err", true),
     ]);
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(0);
     expect(result).toBe(messages);
@@ -100,8 +109,10 @@ describe("postTurnTruncateToolResults", () => {
       makeToolResult(alreadyTruncated, "tool_idempotent"),
     ]);
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(0);
     expect(result).toBe(messages);
@@ -117,8 +128,10 @@ describe("postTurnTruncateToolResults", () => {
       makeToolResult(long2, "tool_long2"),
     ]);
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(2);
 
@@ -174,8 +187,10 @@ describe("postTurnTruncateToolResults", () => {
       { role: "user", content: [makeToolResult(skillBody, toolUseId)] },
     ];
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(0);
     expect(result).toBe(messages); // same reference — no copy
@@ -209,8 +224,10 @@ describe("postTurnTruncateToolResults", () => {
       { role: "user", content: [makeToolResult(longContent, toolUseId)] },
     ];
 
-    const { messages: result, truncatedCount } =
-      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+    const { messages: result, truncatedCount } = postTurnTruncateToolResults(
+      messages,
+      { conversationDir: convDir },
+    );
 
     expect(truncatedCount).toBe(1);
     const block = result[1].content[0] as {
@@ -262,7 +279,38 @@ describe("derefToolResultReReads", () => {
       derefToolResultReReads(messages);
 
     expect(dereferencedCount).toBe(1);
-    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
+    expect(block.content).toBe(REREAD_STUB);
+  });
+
+  test("host_file_read of .tool-results/ path: tool_result content replaced with REREAD_STUB", () => {
+    const toolUseId = "tu_host_reread";
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          makeToolUse(toolUseId, "host_file_read", {
+            path: `/home/user/.local/share/vellum/conversations/abc/${TOOL_RESULT_DIR}/abc123.txt`,
+          }),
+        ],
+      },
+      {
+        role: "user",
+        content: [makeToolResult("full host file contents here", toolUseId)],
+      },
+    ];
+
+    const { messages: result, dereferencedCount } =
+      derefToolResultReReads(messages);
+
+    expect(dereferencedCount).toBe(1);
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
     expect(block.content).toBe(REREAD_STUB);
   });
 
@@ -289,7 +337,10 @@ describe("derefToolResultReReads", () => {
 
     expect(dereferencedCount).toBe(0);
     expect(result).toBe(messages); // same reference — no copy
-    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
     expect(block.content).toBe(originalContent);
   });
 
@@ -316,7 +367,10 @@ describe("derefToolResultReReads", () => {
 
     expect(dereferencedCount).toBe(0);
     expect(result).toBe(messages);
-    const block = result[1].content[0] as { type: "tool_result"; content: string };
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
     expect(block.content).toBe(outputMentioningDir);
   });