@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/runtime/routes/llm-call-sites-routes.ts

@@ -1,14 +1,16 @@
 import { z } from "zod";
 
-import { CALL_SITE_DEFAULTS } from "../../config/call-site-defaults.js";
 import { getUserSelectableProfilesForProvider } from "../../config/default-profile-catalog.js";
-import { resolveDefaultProfileKey } from "../../config/llm-resolver.js";
+import {
+  resolveDefaultProfileKey,
+  resolveShippedDefaultProfileKey,
+} from "../../config/llm-resolver.js";
 import { loadConfig } from "../../config/loader.js";
 import {
   CALL_SITE_CATALOG,
   CALL_SITE_DOMAINS,
 } from "../../config/schemas/call-site-catalog.js";
-import type { LLMCallSite } from "../../config/schemas/llm.js";
+import type { LLMCallSite, LLMConfig } from "../../config/schemas/llm.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -30,7 +32,8 @@ const callSiteEntrySchema = z.object({
    * `defaultProfile` would scatter pinned or remapped sites across their
    * winners. Profileless call sites report `balanced`: the resolver's
    * fallback anchor consults the balanced remap for them, so they follow
-   * the Balanced tier like any balanced-keyed site.
+   * the Balanced tier like any balanced-keyed site. A managed-only tier is
+   * omitted when it has no body under the workspace's default provider.
    */
   shippedDefaultProfile: z.string().optional(),
 });
@@ -40,16 +43,22 @@ const callSiteCatalogResponseSchema = z.object({
   callSites: z.array(callSiteEntrySchema),
 });
 
+export function buildCallSiteCatalog(llm: LLMConfig) {
+  return CALL_SITE_CATALOG.map((entry) => ({
+    ...entry,
+    defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
+    shippedDefaultProfile: resolveShippedDefaultProfileKey(
+      entry.id as LLMCallSite,
+      llm,
+    ),
+  }));
+}
+
 async function handleGetCallSites() {
   const { llm } = loadConfig();
   return {
     domains: CALL_SITE_DOMAINS,
-    callSites: CALL_SITE_CATALOG.map((entry) => ({
-      ...entry,
-      defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
-      shippedDefaultProfile:
-        CALL_SITE_DEFAULTS[entry.id]?.profile ?? "balanced",
-    })),
+    callSites: buildCallSiteCatalog(llm),
   };
 }
 

package/src/runtime/routes/platform-routes.ts

@@ -90,7 +90,12 @@ const PlatformStatusResponseSchema = z.object({
   isPlatform: z.boolean(),
   baseUrl: z.string(),
   assistantId: z.string(),
-  hasAssistantApiKey: z.boolean(),
+  hasAssistantApiKey: z
+    .boolean()
+    .nullable()
+    .describe(
+      "Whether a managed assistant API key is stored. Null when the credential store could not be read, which is not evidence that no key is stored.",
+    ),
   hasWebhookSecret: z.boolean(),
   clientInstallationId: z.string().nullable(),
   available: z.boolean(),

package/src/runtime/routes/plugins-routes.ts

@@ -48,7 +48,10 @@ import {
   type InstalledPluginInfo,
   listInstalledPlugins,
 } from "../../cli/lib/list-installed-plugins.js";
-import { getPluginCatalog } from "../../cli/lib/plugin-catalog-cache.js";
+import {
+  getPluginCatalog,
+  getPluginCatalogForInstalledMetadata,
+} from "../../cli/lib/plugin-catalog-cache.js";
 import { resolvePluginSourceFromCatalog } from "../../cli/lib/plugin-catalog-resolve.js";
 import {
   DEFAULT_PIN_HISTORY_LIMIT,
@@ -969,7 +972,7 @@ export async function loadCategoryMapBounded(
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     const catalog = await Promise.race([
-      getPluginCatalog(DEFAULT_PLUGIN_REF, {
+      getPluginCatalogForInstalledMetadata(DEFAULT_PLUGIN_REF, {
         fetch: globalThis.fetch.bind(globalThis),
       }),
       new Promise<null>((resolve) => {

package/src/runtime/sync/documents-sidecar-publish.test.ts

@@ -1,22 +1,32 @@
 /**
- * A scheduled, heartbeat, or background turn runs its document tools in a
- * sidecar worker, whose local hub has no SSE subscriber. The documents-changed
- * broadcast has to be handed to the daemon there, or the document edited while
- * the user was not looking stays invisible on every client.
+ * A scheduled, heartbeat, or background turn runs its document tools and its
+ * conversation writes in a sidecar worker, whose local hub has no SSE
+ * subscriber. Those broadcasts have to be handed to the daemon there, or the
+ * document edited and the conversation changed while the user was not looking
+ * stay invisible on every client.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let notifyCount = 0;
+const listHandoffs: Array<{ reason: string; conversationIds: string[] }> = [];
 
 mock.module("./worker-daemon-notify.js", () => ({
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD:
     "notify_conversation_persisted_externally",
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD:
+    "notify_conversation_list_changed_externally",
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD: "notify_documents_changed_externally",
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD:
     "notify_activation_progress_changed_externally",
   notifyDaemonActivationProgressChanged: async () => {},
   notifyDaemonConversationPersisted: async () => {},
+  notifyDaemonConversationListChanged: async (
+    reason: string,
+    conversationIds: string[],
+  ) => {
+    listHandoffs.push({ reason, conversationIds });
+  },
   notifyDaemonDocumentsChanged: async () => {
     notifyCount++;
   },
@@ -30,6 +40,7 @@ import {
 } from "../assistant-stream-state.js";
 import {
   DOCUMENTS_CHANGED_COALESCE_MS,
+  publishConversationListAndMetadataChanged,
   publishDocumentsChanged,
 } from "./resource-sync-events.js";
 
@@ -66,6 +77,7 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
   beforeEach(async () => {
     await settle();
     notifyCount = 0;
+    listHandoffs.length = 0;
     _resetStreamStateForTesting();
   });
 
@@ -102,3 +114,37 @@ describe("publishDocumentsChanged in a sidecar worker", () => {
     expect(events[0].message).toMatchObject({ type: "sync_changed" });
   });
 });
+
+describe("publishConversationListAndMetadataChanged in a sidecar worker", () => {
+  beforeEach(async () => {
+    await settle();
+    listHandoffs.length = 0;
+    _resetStreamStateForTesting();
+  });
+
+  test("hands the list invalidation to the daemon instead of publishing into a void", async () => {
+    disableStreamSeqStamping();
+
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([
+      { reason: "reordered", conversationIds: ["conv-1"] },
+    ]);
+    expect(events).toEqual([]);
+  });
+
+  test("publishes on the local hub in the daemon, where subscribers live", async () => {
+    const events = await captureLocalPublishes(() => {
+      publishConversationListAndMetadataChanged("reordered", "conv-1");
+    });
+
+    expect(listHandoffs).toEqual([]);
+    expect(events).toHaveLength(1);
+    expect(events[0].message).toMatchObject({
+      type: "sync_changed",
+      tags: ["conversations:list", "conversation:conv-1:metadata"],
+    });
+  });
+});

package/src/runtime/sync/resource-sync-events.ts

@@ -12,6 +12,7 @@ import { isStreamSeqStampingDisabled } from "../assistant-stream-state.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 import {
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
@@ -236,6 +237,16 @@ export function publishConversationListAndMetadataChanged(
     ? conversationIds
     : [conversationIds];
 
+  // In a sidecar worker the local hub has no SSE subscribers, so a publish
+  // here reaches nobody and the sidebar keeps showing a list the worker has
+  // already changed. Hand off to the daemon, which republishes on the hub
+  // clients actually subscribe to. A background worker turn has no
+  // originating client, so no `originClientId` is forwarded.
+  if (isStreamSeqStampingDisabled()) {
+    void notifyDaemonConversationListChanged(reason, ids);
+    return;
+  }
+
   // Shape-changing reasons (`created`, `deleted`, `reordered`) add or
   // remove rows or change the order of the paginated window — web must
   // refetch the list, so include the `conversationsList` umbrella tag.

package/src/runtime/sync/worker-daemon-notify.test.ts

@@ -33,13 +33,43 @@ mock.module("../../ipc/cli-client.js", () => ({
 
 import {
   NOTIFY_ACTIVATION_PROGRESS_CHANGED_IPC_METHOD,
+  NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
   NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD,
   NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD,
   notifyDaemonActivationProgressChanged,
+  notifyDaemonConversationListChanged,
   notifyDaemonConversationPersisted,
   notifyDaemonDocumentsChanged,
 } from "./worker-daemon-notify.js";
 
+describe("notifyDaemonConversationListChanged", () => {
+  beforeEach(() => {
+    calls.length = 0;
+    nextResult = { ok: true };
+    shouldThrow = false;
+  });
+
+  test("hands the reason and ids to the daemon over the shared IPC method", async () => {
+    await notifyDaemonConversationListChanged("reordered", ["conv-1"]);
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.method).toBe(NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD);
+    expect(calls[0]!.params).toEqual({
+      body: { reason: "reordered", conversationIds: ["conv-1"] },
+    });
+  });
+
+  test("swallows a thrown IPC error (best-effort, no throw)", async () => {
+    shouldThrow = true;
+
+    const result = await notifyDaemonConversationListChanged("reordered", [
+      "conv-1",
+    ]);
+    expect(result).toBeUndefined();
+    expect(calls).toHaveLength(1);
+  });
+});
+
 describe("notifyDaemonConversationPersisted", () => {
   beforeEach(() => {
     calls.length = 0;

package/src/runtime/sync/worker-daemon-notify.ts

@@ -31,6 +31,14 @@ export const NOTIFY_CONVERSATION_PERSISTED_IPC_METHOD =
 export const NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD =
   "notify_documents_changed_externally";
 
+/**
+ * IPC method the daemon exposes for the conversation-list hand-off. Shared by
+ * the worker caller and the daemon route registration so the wire name cannot
+ * drift.
+ */
+export const NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD =
+  "notify_conversation_list_changed_externally";
+
 /**
  * IPC method the daemon exposes for the activation-progress hand-off. Shared
  * by the worker caller and the daemon route registration so the wire name
@@ -79,6 +87,42 @@ export async function notifyDaemonConversationPersisted(
   }
 }
 
+/**
+ * Ask the daemon to republish a conversation-list-and-metadata invalidation.
+ *
+ * A worker turn can change which rows the sidebar should hold, not just what
+ * one row contains: clearing `archived_at` on a Done conversation the turn
+ * woke is the case that matters. The list tag has to reach real subscribers
+ * for the conversation to reappear, and the worker's own hub has none.
+ *
+ * Best-effort by design, like the other hand-offs: an unreachable daemon is
+ * logged at debug and swallowed, and the client picks the change up on its
+ * next list fetch.
+ */
+export async function notifyDaemonConversationListChanged(
+  reason: string,
+  conversationIds: string[],
+): Promise<void> {
+  try {
+    const result = await cliIpcCall(
+      NOTIFY_CONVERSATION_LIST_CHANGED_IPC_METHOD,
+      { body: { reason, conversationIds } },
+      { timeoutMs: NOTIFY_TIMEOUT_MS },
+    );
+    if (!result.ok) {
+      log.debug(
+        { reason, conversationIds, error: result.error },
+        "daemon conversation-list-changed notify was not acknowledged",
+      );
+    }
+  } catch (err) {
+    log.debug(
+      { err, reason, conversationIds },
+      "daemon conversation-list-changed notify failed",
+    );
+  }
+}
+
 /**
  * Ask the daemon to republish the documents-list invalidation.
  *

package/src/runtime/verification-outbound-actions.ts

@@ -278,7 +278,7 @@ async function startOutboundTelegram(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Set rebind: true to replace.",
+        "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel,
     };
   }
@@ -820,7 +820,7 @@ async function startOutboundTextChannel(
       success: false,
       error: "already_bound",
       message:
-        "A guardian is already bound for this channel. Set rebind: true to replace.",
+        "A guardian is already bound for this channel. To verify a different account, revoke the existing binding first. Set rebind: true only to verify the same account again.",
       channel,
     };
   }

package/src/skills/validate-input.ts

@@ -3,10 +3,11 @@
  *
  * Deliberate strict subset of JSON Schema: it covers only the keywords
  * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
- * (required / type / enum / items.type) plus unknown-key detection. Anything
- * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
- * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
- * a richer schema can never cause us to reject a legitimate call.
+ * (required / type / enum / nested properties and items / required-only oneOf)
+ * plus unknown-key detection. Anything else (`$ref`, richer `oneOf`, `anyOf`,
+ * `allOf`, `format`, `pattern`, `minimum`, `maximum`, object-shape
+ * `additionalProperties`, etc.) is skipped. Nested objects allow extra keys
+ * unless their schema explicitly closes them.
  *
  * Each error message is written to be agent-readable and self-correcting
  * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
@@ -313,6 +314,15 @@ export function validateInputAgainstSchema(
   _toolName: string,
   input: Record<string, unknown>,
   schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  return validateObjectInput(input, schema, "", true);
+}
+
+function validateObjectInput(
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+  path: string,
+  rejectUnknown: boolean,
 ): InputValidationResult {
   // Skip when there's no schema or no properties block — matches today's
   // lenient behaviour for tools that declare only `{ type: "object" }`.
@@ -338,17 +348,46 @@ export function validateInputAgainstSchema(
         continue;
       }
       if (!(key in input)) {
-        errors.push(`${key} is required`);
+        errors.push(`${path}${key} is required`);
       }
     }
   }
 
+  // Only enforce alternatives whose complete contract is field presence.
+  // Richer unions stay permissive because unsupported keywords can decide
+  // which branch matches.
+  const alternatives = schema.oneOf;
+  if (
+    Array.isArray(alternatives) &&
+    alternatives.length > 0 &&
+    alternatives.every(
+      (branch) =>
+        isPlainObject(branch) &&
+        Object.keys(branch).every(
+          (key) => key === "required" || key === "description",
+        ) &&
+        Array.isArray(branch.required) &&
+        branch.required.every((key: unknown) => typeof key === "string"),
+    )
+  ) {
+    const choices = alternatives as { required: string[] }[];
+    if (
+      choices.filter((branch) => branch.required.every((key) => key in input))
+        .length !== 1
+    ) {
+      errors.push(
+        `${path ? path.slice(0, -1) : "input"} must match exactly one required field set: ${choices.map((branch) => quoteList(branch.required)).join(" or ")}`,
+      );
+    }
+  }
+
   // 2. Per-property checks: type, enum, items.type.
-  for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!(key in input)) {
+  for (const [property, rawSubSchema] of Object.entries(properties)) {
+    if (!(property in input)) {
       continue;
     }
-    const value = input[key];
+    const key = `${path}${property}`;
+    const value = input[property];
     // Skip type-checking for absent values; presence is enforced by the
     // `required` check above. Note: `null` IS a present value and is
     // type-checked below — only schemas that explicitly opt in to null via
@@ -381,13 +420,25 @@ export function validateInputAgainstSchema(
       if (!matchesType(value, type)) {
         errors.push(
           type === "boolean" && typeof value === "string"
-            ? `${key} must be a boolean — pass true or false as a JSON boolean, not a string`
+            ? `${key} must be a boolean: pass true or false as a JSON boolean, not a string`
             : `${key} must be ${typeArticle(type)} ${type}`,
         );
         // No point checking enum/items if the base type is wrong.
         continue;
       }
 
+      if (type === "object" && isPlainObject(value)) {
+        const nested = validateObjectInput(
+          value,
+          rawSubSchema,
+          `${key}.`,
+          rawSubSchema.additionalProperties === false,
+        );
+        if (!nested.ok) {
+          errors.push(...nested.errors);
+        }
+      }
+
       // 2a. Enum (string enums are the only shape used today).
       const enumValues = rawSubSchema.enum;
       if (Array.isArray(enumValues) && enumValues.length > 0) {
@@ -412,6 +463,17 @@ export function validateInputAgainstSchema(
               errors.push(
                 `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
               );
+            } else if (itemTypeName === "object" && isPlainObject(element)) {
+              const itemSchema = rawSubSchema.items as Record<string, unknown>;
+              const nested = validateObjectInput(
+                element,
+                itemSchema,
+                `${key}[${index}].`,
+                itemSchema.additionalProperties === false,
+              );
+              if (!nested.ok) {
+                errors.push(...nested.errors);
+              }
             }
           });
         }
@@ -420,10 +482,12 @@ export function validateInputAgainstSchema(
   }
 
   // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
-  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  const unknownKeys = rejectUnknown
+    ? Object.keys(input).filter((k) => !knownKeySet.has(k))
+    : [];
   for (const key of unknownKeys) {
     errors.push(
-      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+      `Unknown parameter "${path}${key}". Supported: ${quoteList(knownKeys)}`,
     );
   }
 

package/src/telegram/__tests__/webhook-health.test.ts

@@ -29,8 +29,16 @@ let emitFails = false;
 
 // ── Module mocks ──────────────────────────────────────────────────────
 
+// Spread the real module: mocks are shared across files in a combined run,
+// and a wholesale replacement drops the exports peer modules import.
+const actualSecureKeys = await import("../../security/secure-keys.js");
 mock.module("../../security/secure-keys.js", () => ({
+  ...actualSecureKeys,
   getSecureKeyAsync: async (account: string) => secureKeyValues.get(account),
+  getSecureKeyResultAsync: async (account: string) => ({
+    value: secureKeyValues.get(account),
+    unreachable: false,
+  }),
 }));
 
 mock.module("../../security/credential-key.js", () => ({

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -200,6 +200,44 @@ describe("AskQuestionTool.execute", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("says so when the user answered in the chat instead of the card", async () => {
+    const q2 = {
+      question: "Preferred time?",
+      options: [
+        { id: "morning", label: "Morning" },
+        { id: "afternoon", label: "Afternoon" },
+      ],
+    };
+    setNextResult({
+      entries: [
+        {
+          questionId: "q1",
+          decision: "free_text",
+          text: "banana, after lunch",
+        },
+        { questionId: "q2", decision: "skipped" },
+      ],
+      overall: "completed",
+      answeredInChat: true,
+    });
+
+    const result = await askQuestionTool.execute(
+      { questions: [singleQ, q2] },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const lines = String(result.content).split("\n");
+    // The model is told where the answer came from, then reads the batch: the
+    // typed text on the first question, the rest unanswered, so it can map the
+    // reply onto them itself.
+    expect(lines[0]).toContain("replied in the chat");
+    expect(lines.slice(1)).toEqual([
+      `Question "${singleQ.question}" → Free text: banana, after lunch`,
+      `Question "${q2.question}" → Skipped`,
+    ]);
+  });
+
   test("formats skipped result", async () => {
     setNextResult(singleCompleted({ decision: "skipped" }));
     const result = await askQuestionTool.execute(validInput, makeContext());

package/src/tools/ask-question/ask-question-tool.ts

@@ -243,6 +243,15 @@ export function toAnsweredQuestion(
   };
 }
 
+/**
+ * Model-facing note prepended when the user answered by typing in the chat
+ * instead of using the card. The text lands as free text on the first
+ * question and every other question reads as skipped, so the model is told
+ * plainly what happened and left to map the reply onto the batch itself.
+ */
+const CHAT_REPLY_PREAMBLE =
+  "The user replied in the chat instead of using the question card, so their message is recorded as free text on the first question below and the remaining questions are unanswered. Read their reply as the answer to whichever questions it covers, and ask again only for what it genuinely leaves open.";
+
 // ── Tool ────────────────────────────────────────────────────────────
 
 /**
@@ -389,7 +398,9 @@ export const askQuestionTool = {
 
     switch (result.overall) {
       case "completed": {
-        let content = lines.join("\n");
+        let content = result.answeredInChat
+          ? [CHAT_REPLY_PREAMBLE, ...lines].join("\n")
+          : lines.join("\n");
         if (desktopHelp) {
           const entry = result.entries[0];
           if (entry?.decision === "free_text") {

package/src/tools/network/__tests__/web-fetch-firecrawl.test.ts

@@ -1,4 +1,12 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 
 import { setConfig } from "../../../__tests__/helpers/set-config.js";
 
@@ -133,6 +141,25 @@ describe("executeFirecrawlScrape", () => {
     expect(result.status).toContain("truncated");
   });
 
+  test("carries the provider's warning and a start past the end in metadata", async () => {
+    spyOn(globalThis, "fetch").mockResolvedValue(
+      scrapeResponse({
+        success: true,
+        warning: "The page was served from cache.",
+        data: { markdown: "abcdefghij", metadata: { statusCode: 200 } },
+      }),
+    );
+
+    const result = await executeFirecrawlScrape(
+      { url: "https://example.com", start_index: 50 },
+      { apiKey: "fc-key" },
+    );
+    expect(result.isError).toBe(false);
+    const meta = result.activityMetadata?.webFetch;
+    expect(meta?.providerWarning).toBe("The page was served from cache.");
+    expect(meta?.startIndexPastEnd).toBe(true);
+  });
+
   test("empty markdown yields a no-content marker, not an error", async () => {
     globalThis.fetch = (async () =>
       scrapeResponse({ success: true, data: { markdown: "" } })) as any;

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

@@ -130,6 +130,40 @@ describe("web_fetch activityMetadata", () => {
     expect(meta?.charCount).toBe(maxChars);
   });
 
+  test("flags a start_index past the end of a page it downloaded whole", async () => {
+    const result = await executeWithMockFetch(
+      { url: "https://example.com/short", start_index: 500 },
+      {
+        requestExecutor: async () =>
+          new Response("x".repeat(100), {
+            status: 200,
+            headers: { "content-type": "text/plain; charset=utf-8" },
+          }),
+      },
+    );
+    expect(result.isError).toBe(false);
+    expect(result.activityMetadata?.webFetch?.startIndexPastEnd).toBe(true);
+  });
+
+  test("does not call a start_index past a capped download the end of the page", async () => {
+    // Over the 2 MB download cap: only a prefix is read, so an offset past it
+    // may still be inside the page.
+    const result = await executeWithMockFetch(
+      { url: "https://example.com/huge", start_index: 2_500_000 },
+      {
+        requestExecutor: async () =>
+          new Response("x".repeat(3_000_000), {
+            status: 200,
+            headers: { "content-type": "text/plain; charset=utf-8" },
+          }),
+      },
+    );
+    expect(result.isError).toBe(false);
+    const meta = result.activityMetadata?.webFetch;
+    expect(meta?.truncated).toBe(true);
+    expect(meta?.startIndexPastEnd).toBe(false);
+  });
+
   test("populates errorMessage and status on a 404 response", async () => {
     globalThis.fetch = (async () =>
       new Response("<title>Not Found</title>not here", {