@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, test } from "bun:test";
 import { eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
+import { migrateScheduleSourceConversation } from "../memory/migrations/270-schedule-source-conversation.js";
 import * as schema from "../memory/schema.js";
 import { scheduleJobs } from "../memory/schema.js";
 
@@ -38,6 +39,7 @@ describe("schedule_syntax column migration", () => {
         retry_count INTEGER NOT NULL DEFAULT 0,
         max_retries INTEGER NOT NULL DEFAULT 3,
         retry_backoff_ms INTEGER NOT NULL DEFAULT 60000,
+        created_from_conversation_id TEXT,
         created_by TEXT NOT NULL,
         mode TEXT NOT NULL DEFAULT 'execute',
         routing_intent TEXT NOT NULL DEFAULT 'all_channels',
@@ -134,6 +136,7 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* already exists */
     }
+    migrateScheduleSourceConversation(db);
 
     const row = db
       .select()
@@ -197,6 +200,8 @@ describe("schedule_syntax column migration", () => {
     } catch {
       /* ok */
     }
+    migrateScheduleSourceConversation(db);
+    migrateScheduleSourceConversation(db);
 
     const now = Date.now();
     raw.exec(

package/src/__tests__/dm-persistence.test.ts

@@ -94,10 +94,14 @@ function createSlackTurnContext(): MessagingConversationContext {
     drain: () => [],
     size: () => 0,
   } as unknown as MessageQueue;
+  let processing = false;
   return {
     conversationId: "conv-dm-test",
     messages: [],
-    processing: false,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: null,
     queue: queueStub,
     getTurnChannelContext: () => channel,

package/src/__tests__/empty-response-hook.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Tests for the default `empty-response` plugin's `stop` hook.
+ *
+ * Covers:
+ * - The default hook's binary decision for the canonical cases: empty turn
+ *   after a prior tool-use turn → continue (with the canonical nudge text);
+ *   visible text → stop; prior turn already delivered visible text → stop;
+ *   first model call with no prior turn → stop; provider refusal → continue
+ *   (with the refusal-specific nudge text); refusal-but-recovered → stop.
+ * - The hook scopes its prior-turn signals to the current response cycle (the
+ *   messages after the last genuine user prompt), so visible text from the
+ *   inbound conversation does not suppress the nudge.
+ * - When the hook continues, it appends the nudge as a `user` message to
+ *   `messages`.
+ * - End-to-end through `runHook` + the registry: registering the default
+ *   plugin makes the hook fire, and a later-registered user hook chains after
+ *   it and can read/override the decision.
+ *
+ * The loop's actual side-effects (retry-budget cap, history splice, log
+ * emission) live in `agent/loop.ts` and are covered by integration tests in
+ * `conversation-agent-loop.test.ts` / `agent-loop.test.ts`. This file isolates
+ * the hook.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { HOOKS } from "../plugin-api/constants.js";
+import type { PluginLogger, StopContext } from "../plugin-api/types.js";
+import {
+  NUDGE_TEXT,
+  REFUSAL_NUDGE_TEXT,
+} from "../plugins/defaults/empty-response/hooks/stop.js";
+import stop from "../plugins/defaults/empty-response/hooks/stop.js";
+import { defaultEmptyResponsePlugin } from "../plugins/defaults/empty-response/register.js";
+import { runHook } from "../plugins/pipeline.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const noopLogger: PluginLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+const emptyTextBlock: ContentBlock = { type: "text", text: "   " };
+
+/** A prior assistant turn that issued a tool call but no visible text. */
+const priorToolUseTurn: Message = {
+  role: "assistant",
+  content: [{ type: "tool_use", id: "tu_1", name: "read_file", input: {} }],
+};
+
+/** A prior assistant turn that delivered visible text to the user. */
+const priorVisibleTextTurn: Message = {
+  role: "assistant",
+  content: [{ type: "text", text: "here is what I found earlier" }],
+};
+
+/** A genuine user prompt — the boundary that opens a new response cycle. */
+function userPrompt(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+function makeCtx(overrides: Partial<StopContext> = {}): StopContext {
+  return {
+    conversationId: "conv-stop",
+    messages: [],
+    responseContent: [],
+    stopReason: null,
+    decision: "stop",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+// ─── Default decisions ───────────────────────────────────────────────────────
+
+describe("empty-response stop hook — default decisions", () => {
+  test("empty turn after a prior tool-use turn → continue with canonical nudge", async () => {
+    // GIVEN a run that already issued a tool call, then returned an empty
+    // (whitespace-only) assistant turn with no visible text.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [emptyTextBlock],
+    });
+
+    // WHEN the default stop hook runs.
+    await stop(ctx);
+
+    // THEN it asks the loop to continue and appends the canonical nudge.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("turn contains visible text → stop", async () => {
+    // GIVEN a turn that delivered visible text.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [{ type: "text", text: "here is a summary" }],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop and nothing is appended.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+
+  test("prior turn already delivered visible text → stop", async () => {
+    // GIVEN the model said its piece in an earlier turn this run, then ended
+    // with a side-effect tool and returned empty. Nudging would force a
+    // verbatim re-send of text the user already saw.
+    const ctx = makeCtx({
+      messages: [userPrompt("do X"), priorVisibleTextTurn, priorToolUseTurn],
+      responseContent: [],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("visible text before the last user prompt is ignored → continue", async () => {
+    // GIVEN the inbound conversation already contains an assistant turn with
+    // visible text, but it precedes this run's user prompt. The current cycle
+    // (after that prompt) holds only a tool-use turn, so the earlier text
+    // belongs to the prior conversation and must not suppress the nudge.
+    const ctx = makeCtx({
+      messages: [
+        priorVisibleTextTurn,
+        userPrompt("do the next thing"),
+        priorToolUseTurn,
+      ],
+      responseContent: [],
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues — the cycle scope sees only the tool-use turn, not the
+    // inbound conversation's visible text.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("first model call with no prior turn → stop", async () => {
+    // GIVEN an empty first assistant response with no prior turn this run and
+    // no refusal — not the pattern the organic-empty-turn nudge guards against.
+    const ctx = makeCtx({ messages: [], responseContent: [] });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  // ─── Refusal stop ──────────────────────────────────────────────────────────
+
+  test("refusal on the first call with no content → continue with refusal nudge", async () => {
+    // GIVEN the canonical failure mode: the provider's safety classifier zeros
+    // the response on the very first model call, returning `stopReason:
+    // "refusal"` and no visible text.
+    const ctx = makeCtx({
+      messages: [],
+      responseContent: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues with the refusal-specific nudge, even with no prior turn.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+
+  test("refusal with a thinking-only block still continues", async () => {
+    // GIVEN a refusal whose only content is a thinking block — the user sees
+    // nothing.
+    const ctx = makeCtx({
+      messages: [],
+      responseContent: [
+        { type: "thinking", thinking: "...", signature: "sig" },
+      ],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN it continues with the refusal-specific nudge.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+
+  test("refusal but visible text present → stop (model recovered)", async () => {
+    // GIVEN a refusal that still delivered some visible text before refusing —
+    // the user has something to see.
+    const ctx = makeCtx({
+      responseContent: [{ type: "text", text: "partial answer" }],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN the decision stays at stop.
+    expect(ctx.decision).toBe("stop");
+  });
+
+  test("refusal beats the post-tool-empty nudge wording", async () => {
+    // GIVEN conditions that would trip both the refusal branch and the
+    // post-tool-empty branch.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      responseContent: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await stop(ctx);
+
+    // THEN refusal wins because its wording is more accurate.
+    expect(ctx.decision).toBe("continue");
+    expect(ctx.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    });
+  });
+});
+
+// ─── Via runHook + registry ──────────────────────────────────────────────────
+
+describe("empty-response stop hook — via runHook", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("registering the default plugin makes the hook continue on empty-after-tools", async () => {
+    // GIVEN the default empty-response plugin is registered.
+    registerPlugin(defaultEmptyResponsePlugin);
+
+    // WHEN the stop chain runs over an empty-after-tools context.
+    const result = await runHook<StopContext>(
+      HOOKS.STOP,
+      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    );
+
+    // THEN the chain settles on continue with the canonical nudge appended.
+    expect(result.decision).toBe("continue");
+    expect(result.messages.at(-1)).toEqual({
+      role: "user",
+      content: [{ type: "text", text: NUDGE_TEXT }],
+    });
+  });
+
+  test("a later-registered user hook can override the default decision", async () => {
+    // GIVEN the default plugin registers first, then a user plugin whose hook
+    // observes the default's decision and forces a stop.
+    let observedDecision: string | null = null;
+    registerPlugin(defaultEmptyResponsePlugin);
+    registerPlugin({
+      manifest: { name: "force-stop", version: "0.0.1" },
+      hooks: {
+        stop: async (ctx: StopContext) => {
+          observedDecision = ctx.decision;
+          ctx.decision = "stop";
+        },
+      },
+    });
+
+    // WHEN the chain runs over an empty-after-tools context.
+    const result = await runHook<StopContext>(
+      HOOKS.STOP,
+      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    );
+
+    // THEN the user hook saw the default's continue, and its override wins.
+    expect(observedDecision as string | null).toBe("continue");
+    expect(result.decision).toBe("stop");
+  });
+});

package/src/__tests__/feature-flag-test-helpers.ts

@@ -19,7 +19,7 @@
 // Mirrors `src/config/feature-flag-cache.ts`. Duplicated by design — see
 // the "No source-module imports" section above.
 type FlagSlot = {
-  overrides: Record<string, boolean> | null;
+  overrides: Record<string, boolean | string> | null;
   fromGateway: boolean;
 };
 
@@ -45,7 +45,7 @@ function flagSlot(): FlagSlot {
  * `clearFeatureFlagOverridesCache()` from `assistant-feature-flags.ts`.
  */
 export function setOverridesForTesting(
-  overrides: Record<string, boolean>,
+  overrides: Record<string, boolean | string>,
 ): void {
   const s = flagSlot();
   s.overrides = { ...overrides };

package/src/__tests__/gemini-image-service.test.ts

@@ -287,6 +287,19 @@ describe("mapGeminiError", () => {
     expect(msg).toContain("Rate limit");
   });
 
+  test("maps 402 status to a non-retryable out-of-credits message", () => {
+    const msg = mapGeminiError(new FakeApiError(402, "payment required"));
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Please try again");
+  });
+
+  test("maps a managed-proxy 402 failure (plain Error) to out-of-credits message", () => {
+    const msg = mapGeminiError(
+      new Error("Managed proxy request failed (402): insufficient credits"),
+    );
+    expect(msg).toContain("out of credits");
+  });
+
   test("maps 500 status to server error message", () => {
     const msg = mapGeminiError(new FakeApiError(500, "internal"));
     expect(msg).toContain("temporarily unavailable");

package/src/__tests__/helpers/mock-provider.ts

@@ -0,0 +1,110 @@
+// Type-only import: this binds the mock to the real `Provider` contract so it
+// can be passed to a live `AgentLoop` without casts. It must stay `import type`
+// — a value import would pull `providers/types.ts`'s runtime exports into this
+// shared helper, which the test-machinery isolation rule forbids.
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../../providers/types.js";
+
+/**
+ * Records the arguments of a single `provider.sendMessage` invocation so tests
+ * can assert on what the agent loop sent (messages, tools, system prompt, the
+ * resolved options bag).
+ */
+export interface RecordedProviderCall {
+  messages: Message[];
+  tools?: ToolDefinition[];
+  systemPrompt?: string;
+  options?: SendMessageOptions;
+}
+
+/**
+ * One scripted provider turn. A `ProviderResponse` is returned normally; an
+ * `Error` is thrown to simulate a provider HTTP rejection (e.g. a
+ * context-too-large error the orchestrator must recover from).
+ */
+export type ScriptedResponse = ProviderResponse | Error;
+
+/**
+ * A mock provider that returns pre-configured responses in sequence.
+ *
+ * Drives the real {@link import("../../agent/loop.js").AgentLoop} by mocking
+ * only the provider HTTP boundary: each call returns the next scripted
+ * `ProviderResponse` (the last response repeats once the script is exhausted)
+ * and replays its text blocks as `text_delta` events so the loop streams
+ * exactly as it would against a live provider. A scripted `Error` entry is
+ * thrown instead of returned, so a rejection can be sequenced before a
+ * recovery response.
+ */
+export function createMockProvider(
+  responses: ScriptedResponse[],
+  name = "mock",
+): {
+  provider: Provider;
+  calls: RecordedProviderCall[];
+} {
+  const calls: RecordedProviderCall[] = [];
+  let callIndex = 0;
+
+  const provider: Provider = {
+    name,
+    async sendMessage(
+      messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      calls.push({
+        messages: [...messages],
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+        options,
+      });
+      const scripted = responses[callIndex] ?? responses[responses.length - 1];
+      callIndex++;
+
+      if (scripted instanceof Error) {
+        throw scripted;
+      }
+
+      // Replay streaming deltas for text blocks, mirroring a live provider.
+      if (options?.onEvent) {
+        for (const block of scripted.content) {
+          if (block.type === "text") {
+            options.onEvent({ type: "text_delta", text: block.text });
+          }
+        }
+      }
+
+      return scripted;
+    },
+  };
+
+  return { provider, calls };
+}
+
+/** A scripted assistant turn that ends with a plain text response. */
+export function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+/** A scripted assistant turn that invokes a single tool. */
+export function toolUseResponse(
+  id: string,
+  name: string,
+  input: Record<string, unknown>,
+): ProviderResponse {
+  return {
+    content: [{ type: "tool_use", id, name, input }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "tool_use",
+  };
+}

package/src/__tests__/helpers/native-web-search-harness.ts

@@ -0,0 +1,129 @@
+/**
+ * Shared test harness for driving the daemon's native `server_tool_complete`
+ * web_search handler in isolation (ATL-727).
+ *
+ * Both `native-web-search.test.ts` and `web-search-backend-failure.test.ts`
+ * exercise the same handler the same way: build a set of mocked
+ * `EventHandlerDeps` (capturing emitted `ServerMessage`s and `rlog.warn`
+ * records), then drive a `server_tool_start` → `server_tool_complete` pair.
+ * This module is the single source of truth for that harness so the two suites
+ * cannot drift apart.
+ *
+ * Note: each consuming test file must still install its own
+ * `mock.module(...)` stubs for the daemon collaborators the handler imports at
+ * load time (config loader, conversation-crud, llm-request-log-store), because
+ * Bun's `mock.module()` is scoped to the file that registers it.
+ */
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../../daemon/conversation-agent-loop-handlers.js";
+import { dispatchAgentEvent } from "../../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../../daemon/message-protocol.js";
+
+/** A `tool_result` `ServerMessage` emitted by the handler. */
+export type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+
+/** A captured `rlog.warn(obj, msg)` call. */
+export interface LogRecord {
+  obj: Record<string, unknown>;
+  msg?: string;
+}
+
+export interface HandlerHarness {
+  deps: EventHandlerDeps;
+  /** Every `ServerMessage` the handler emitted via `onEvent`. */
+  events: ServerMessage[];
+  /** Every `rlog.warn(obj, msg)` call the handler made. */
+  warnings: LogRecord[];
+}
+
+/** Build mocked handler deps that capture emitted events and warn logs. */
+export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
+  const events: ServerMessage[] = [];
+  const warnings: LogRecord[] = [];
+  const rlog = {
+    warn: (obj: Record<string, unknown>, msg?: string) =>
+      warnings.push({ obj, msg }),
+    info: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+  };
+  const deps = {
+    ctx: {
+      conversationId: "conv-web-search",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (msg: ServerMessage) => events.push(msg),
+    reqId,
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: rlog as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+  return { deps, events, warnings };
+}
+
+/** The `server_tool_complete` payload shape a test supplies. */
+export interface WebSearchCompleteEvent {
+  isError: boolean;
+  errorCode?: string;
+  errorMessage?: string;
+  content?: unknown[];
+}
+
+/** Drive one native (Anthropic) web_search start → complete pair. */
+export async function completeNativeWebSearch(
+  state: EventHandlerState,
+  deps: EventHandlerDeps,
+  toolUseId: string,
+  event: WebSearchCompleteEvent,
+): Promise<void> {
+  await dispatchAgentEvent(state, deps, {
+    type: "server_tool_start",
+    name: "web_search",
+    toolUseId,
+    input: { query: "what is the weather" },
+  });
+  await dispatchAgentEvent(state, deps, {
+    type: "server_tool_complete",
+    toolUseId,
+    isError: event.isError,
+    ...(event.errorCode ? { errorCode: event.errorCode } : {}),
+    ...(event.errorMessage ? { errorMessage: event.errorMessage } : {}),
+    content: event.content ?? [],
+  });
+}
+
+/** All `tool_result` events emitted so far, in order. */
+export function toolResults(events: ServerMessage[]): ToolResultEvent[] {
+  return events.filter((e): e is ToolResultEvent => e.type === "tool_result");
+}
+
+/** The most recent `tool_result` event, if any. */
+export function lastToolResult(
+  events: ServerMessage[],
+): ToolResultEvent | undefined {
+  const results = toolResults(events);
+  return results[results.length - 1];
+}
+
+/** The captured `web_search_backend_failure` telemetry warn records. */
+export function backendFailureLogs(warnings: LogRecord[]): LogRecord[] {
+  return warnings.filter((w) => w.obj.event === "web_search_backend_failure");
+}

package/src/__tests__/history-repair-hook.test.ts

@@ -40,6 +40,7 @@ const noopLogger: PluginLogger = {
 function makeCtx(messages: Message[]): UserPromptSubmitContext {
   return {
     conversationId: "conv-test",
+    prompt: "",
     originalMessages: messages,
     latestMessages: messages,
     logger: noopLogger,