@vellumai/assistant 0.6.2 → 0.6.4

package/src/prompts/update-bulletin-format.ts

@@ -42,18 +42,35 @@ export function appendReleaseBlock(
 }
 
 /**
- * Extracts content-level markers (non-version feature markers) from the
- * template body. These are markers like `schedule-reminder-unification`
- * that identify the _content_ rather than the release version.
+ * Filters template content to only include content blocks whose opening
+ * markers are not already present in the existing workspace content.
+ *
+ * Each content block is delimited by opening/closing marker pairs:
+ *   <!-- vellum-update-release:id --> ... <!-- /vellum-update-release:id -->
+ *
+ * If the template has no block structure (no matched open/close pairs),
+ * returns the original body unchanged for backward compatibility.
+ * Returns empty string when all blocks are already present.
  */
-export function extractContentMarkers(body: string): string[] {
-  const ids: string[] = [];
-  const regex = /<!-- vellum-update-release:(.+?) -->/g;
+export function filterNewContentBlocks(
+  body: string,
+  existing: string,
+): string {
+  const blockRegex =
+    /(<!-- vellum-update-release:(.+?) -->[\s\S]*?<!-- \/vellum-update-release:\2 -->)/g;
+  const blocks: Array<{ full: string; id: string }> = [];
   let match: RegExpExecArray | null;
-  while ((match = regex.exec(body)) !== null) {
-    ids.push(match[1]);
+  while ((match = blockRegex.exec(body)) !== null) {
+    blocks.push({ full: match[1], id: match[2] });
   }
-  return ids;
+
+  if (blocks.length === 0) return body;
+
+  const newBlocks = blocks.filter((b) => !hasReleaseBlock(existing, b.id));
+
+  if (newBlocks.length === 0) return "";
+
+  return newBlocks.map((b) => b.full).join("\n\n");
 }
 
 /** Extracts all version strings from release markers found in `content`. */

package/src/prompts/update-bulletin.ts

@@ -8,14 +8,14 @@ import {
   writeFileSync,
 } from "node:fs";
 
+import { getConfig } from "../config/loader.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
 import { APP_VERSION } from "../version.js";
 import {
   appendReleaseBlock,
-  extractContentMarkers,
+  filterNewContentBlocks,
   hasReleaseBlock,
-  releaseMarker,
 } from "./update-bulletin-format.js";
 import {
   addActiveRelease,
@@ -67,25 +67,43 @@ function atomicWriteFileSync(filePath: string, content: string): void {
 /**
  * Materializes the current release's update bulletin on startup.
  *
- * First checks for deletion-completion: if the workspace UPDATES.md was
- * deleted while releases were active, those releases are marked completed
- * (the assistant signals "done" by deleting the file).
+ * First checks for dismissal: if the workspace UPDATES.md was deleted or
+ * emptied after we'd previously materialized it, that's an explicit signal
+ * (from the user or the assistant) that the current release has been handled.
+ * Mark any active releases plus the current release as completed and return
+ * without recreating the file.
  *
- * Then reads the bundled UPDATES.md template, strips comment lines, and
- * appends a release block to the workspace UPDATES.md if one doesn't
- * already exist for this version. Skips completed releases entirely.
+ * Otherwise reads the bundled UPDATES.md template, strips comment lines, and
+ * appends a release block to the workspace UPDATES.md if one doesn't already
+ * exist for this version. Skips completed releases entirely.
  */
 export function syncUpdateBulletinOnStartup(): void {
+  if (!getConfig().updates.enabled) return;
+
   const currentReleaseId = APP_VERSION;
   const workspacePath = getWorkspacePromptPath("UPDATES.md");
 
-  // --- Deletion completion ---
-  // If UPDATES.md was deleted and there are active releases, the assistant
-  // has signaled it is done with those updates. Mark them completed.
+  // --- Dismissal detection ---
+  // If UPDATES.md is missing or empty AND the CURRENT release has been
+  // materialized before (i.e. it's in the active set, or already marked
+  // completed), treat it as a dismissal: mark the active set plus the
+  // current release completed and stop. Scoping to the current release is
+  // critical — a prior release having been completed must NOT cause a new
+  // version's bulletin to be suppressed as "already dismissed". It also
+  // preserves fresh-install semantics: on a brand-new DB we want to create
+  // the file, not treat its absence as dismissal.
   const activeReleases = getActiveReleases();
-  if (!existsSync(workspacePath) && activeReleases.length > 0) {
-    markReleasesCompleted(activeReleases);
+  const fileMissing = !existsSync(workspacePath);
+  const fileEmpty =
+    !fileMissing && readFileSync(workspacePath, "utf-8").trim().length === 0;
+  const currentReleaseMaterialized =
+    activeReleases.includes(currentReleaseId) ||
+    isReleaseCompleted(currentReleaseId);
+
+  if ((fileMissing || fileEmpty) && currentReleaseMaterialized) {
+    markReleasesCompleted([...activeReleases, currentReleaseId]);
     setActiveReleases([]);
+    return;
   }
 
   // --- Template materialization ---
@@ -105,19 +123,12 @@ export function syncUpdateBulletinOnStartup(): void {
   } else {
     const existing = readFileSync(workspacePath, "utf-8");
     if (!hasReleaseBlock(existing, currentReleaseId)) {
-      // Guard: skip if the template's content markers already exist in the
-      // workspace file. This prevents the same update notes from being
-      // appended on every version bump when the template isn't cleared.
-      const contentMarkers = extractContentMarkers(templateContent);
-      const allContentAlreadyPresent =
-        contentMarkers.length > 0 &&
-        contentMarkers.every((m) => existing.includes(releaseMarker(m)));
-
-      if (!allContentAlreadyPresent) {
+      const contentToAppend = filterNewContentBlocks(templateContent, existing);
+      if (contentToAppend.length > 0) {
         const updated = appendReleaseBlock(
           existing,
           currentReleaseId,
-          templateContent,
+          contentToAppend,
         );
         atomicWriteFileSync(workspacePath, updated);
       }

package/src/prompts/user-reference.ts

@@ -1,16 +1,18 @@
-import { readTextFileSync } from "../util/fs.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
+import { resolveGuardianPersonaStrict } from "./persona-resolver.js";
 
 export const DEFAULT_USER_REFERENCE = "my human";
 export const DECLINED_BY_USER_SENTINEL = "declined_by_user";
 
 /**
- * Read the raw "Preferred name/reference:" value from USER.md.
- * Returns the trimmed value when present, or `null` when the file
- * is missing, unreadable, or the field is empty.
+ * Read the raw "Preferred name/reference:" value from the guardian's
+ * per-user persona file (`users/<slug>.md`).
+ *
+ * Returns the trimmed value when present, or `null` when no guardian
+ * is resolvable, the persona file is missing / empty, or the field
+ * itself is blank.
  */
 function readPreferredNameFromUserMd(): string | null {
-  const content = readTextFileSync(getWorkspacePromptPath("USER.md"));
+  const content = resolveGuardianPersonaStrict();
   if (content != null) {
     const match = content.match(/Preferred name\/reference:[ \t]*(.*)/);
     if (match && match[1].trim()) {
@@ -24,9 +26,9 @@ function readPreferredNameFromUserMd(): string | null {
  * Resolve the name/reference the assistant uses when referring to
  * the human it represents in external communications.
  *
- * Reads the "Preferred name/reference:" field from USER.md.
- * Falls back to "my human" when the file is missing, unreadable,
- * or the field is empty.
+ * Reads the "Preferred name/reference:" field from the guardian's
+ * persona file. Falls back to "my human" when the file is missing,
+ * unreadable, or the field is empty.
  */
 export function resolveUserReference(): string {
   const preferredName = readPreferredNameFromUserMd();
@@ -37,9 +39,9 @@ export function resolveUserReference(): string {
 }
 
 /**
- * Resolve the user's pronouns from USER.md.  Returns `null` when the
- * file is missing, the field is empty, or the value is a sentinel like
- * `declined_by_user`.
+ * Resolve the user's pronouns from the guardian's per-user persona file.
+ * Returns `null` when no guardian is resolvable, the file is missing,
+ * the field is empty, or the value is a sentinel like `declined_by_user`.
  *
  * When a legacy `## Onboarding Snapshot` section exists, a `Pronouns:`
  * line *above* that section takes priority (explicit post-onboarding edit).
@@ -47,7 +49,7 @@ export function resolveUserReference(): string {
  * in the file.
  */
 export function resolveUserPronouns(): string | null {
-  const content = readTextFileSync(getWorkspacePromptPath("USER.md"));
+  const content = resolveGuardianPersonaStrict();
   if (content == null) return null;
 
   const snapshotIdx = content.indexOf("## Onboarding Snapshot");
@@ -82,10 +84,11 @@ function cleanPronounValue(raw: string): string | null {
  * Resolve the guardian's display name.
  *
  * Priority:
- *   1. USER.md "Preferred name/reference:" — the user-editable, actively
- *      maintained source of truth.
- *   2. guardianDisplayName (fallback for when USER.md is missing or empty,
- *      e.g. pre-onboarding). Callers pass in Contact.displayName.
+ *   1. Guardian persona file "Preferred name/reference:" — the
+ *      user-editable, actively maintained source of truth.
+ *   2. guardianDisplayName (fallback for when the persona file is
+ *      missing or empty, e.g. pre-onboarding). Callers pass in
+ *      Contact.displayName.
  *   3. DEFAULT_USER_REFERENCE ("my human").
  */
 export function resolveGuardianName(

package/src/providers/__tests__/provider-secret-catalog.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+
+import { API_KEY_PROVIDERS } from "../provider-secret-catalog.js";
+
+// ---------------------------------------------------------------------------
+// API_KEY_PROVIDERS derivation invariants
+// ---------------------------------------------------------------------------
+
+describe("API_KEY_PROVIDERS", () => {
+  test("includes deepgram (shared by STT and TTS catalogs)", () => {
+    expect(API_KEY_PROVIDERS).toContain("deepgram");
+  });
+
+  test("includes deepgram exactly once despite appearing in both STT and TTS catalogs", () => {
+    const occurrences = API_KEY_PROVIDERS.filter((p) => p === "deepgram");
+    expect(occurrences.length).toBe(1);
+  });
+
+  test("includes openai exactly once (shared by LLM and STT)", () => {
+    const occurrences = API_KEY_PROVIDERS.filter((p) => p === "openai");
+    expect(occurrences.length).toBe(1);
+  });
+
+  test("contains no duplicate entries", () => {
+    const unique = new Set(API_KEY_PROVIDERS);
+    expect(API_KEY_PROVIDERS.length).toBe(unique.size);
+  });
+
+  test("is deterministic across calls", () => {
+    // Re-import would return the same module-level constant, but this
+    // validates that the composition does not introduce non-determinism.
+    const first = [...API_KEY_PROVIDERS];
+    const second = [...API_KEY_PROVIDERS];
+    expect(first).toEqual(second);
+  });
+
+  test("includes core LLM providers", () => {
+    expect(API_KEY_PROVIDERS).toContain("anthropic");
+    expect(API_KEY_PROVIDERS).toContain("openai");
+    expect(API_KEY_PROVIDERS).toContain("gemini");
+  });
+});

package/src/providers/anthropic/client.ts

@@ -1,9 +1,11 @@
 import Anthropic from "@anthropic-ai/sdk";
 
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/system-prompt.js";
+import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
+import { stripOrphanedSurrogatesDeep } from "../../util/unicode.js";
 import { createStreamTimeout } from "../stream-timeout.js";
 import type {
   ContentBlock,
@@ -19,6 +21,35 @@ const log = getLogger("anthropic-client");
 /** Validation-specific timeout (10s) so a stalled network doesn't block key submission. */
 const VALIDATION_TIMEOUT_MS = 10_000;
 
+/** Rate-limit the orphaned-surrogate warning so a single bad stream can't flood logs. */
+const ORPHAN_WARNING_THROTTLE_MS = 60_000;
+let lastOrphanWarningMs = 0;
+
+function logOrphanedSurrogateWarning(
+  fixedStringCount: number,
+  messages: Anthropic.MessageParam[],
+): void {
+  const now = Date.now();
+  if (now - lastOrphanWarningMs < ORPHAN_WARNING_THROTTLE_MS) return;
+  lastOrphanWarningMs = now;
+  const blockTypes = new Set<string>();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (typeof block !== "object" || block == null) continue;
+      const type = (block as { type?: string }).type;
+      if (type) blockTypes.add(type);
+    }
+  }
+  log.warn(
+    {
+      fixedStringCount,
+      blockTypes: Array.from(blockTypes),
+    },
+    "stripped orphaned UTF-16 surrogates from outbound Anthropic request — upstream truncation is not surrogate-aware",
+  );
+}
+
 /**
  * Validate an Anthropic API key by making a lightweight GET /v1/models call.
  * Returns `{ valid: true }` on success or `{ valid: false, reason: string }` on failure.
@@ -361,7 +392,10 @@ function repairOrphanedServerToolUse(
         repairedContent.push({
           type: "web_search_tool_result",
           tool_use_id: block.id,
-          content: [],
+          content: {
+            type: "web_search_tool_result_error",
+            error_code: "unavailable",
+          },
         } as unknown as Anthropic.ContentBlockParam);
       }
     }
@@ -564,9 +598,22 @@ export class AnthropicProvider implements Provider {
       useNativeWebSearch?: boolean;
       streamTimeoutMs?: number;
       baseURL?: string;
+      /**
+       * Authenticate via `Authorization: Bearer <token>` instead of
+       * `x-api-key`. Required for proxies that front the Anthropic Messages
+       * API with their own Bearer scheme (e.g. OpenRouter). When set, the
+       * positional `apiKey` argument is ignored on the wire.
+       */
+      authToken?: string;
     } = {},
   ) {
-    this.client = new Anthropic({ apiKey, baseURL: options.baseURL });
+    this.client = options.authToken
+      ? new Anthropic({
+          apiKey: null,
+          authToken: options.authToken,
+          baseURL: options.baseURL,
+        })
+      : new Anthropic({ apiKey, baseURL: options.baseURL });
     this.model = model;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
@@ -579,7 +626,10 @@ export class AnthropicProvider implements Provider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const { config, onEvent, signal } = options ?? {};
-    const cacheTtl: "5m" | "1h" = ((config as Record<string, unknown> | undefined)?.cacheTtl as "5m" | "1h") ?? "1h";
+    const cacheTtl: "5m" | "1h" =
+      ((config as Record<string, unknown> | undefined)?.cacheTtl as
+        | "5m"
+        | "1h") ?? "1h";
     let sentMessages: Anthropic.MessageParam[] | undefined;
     try {
       const formatted = messages
@@ -689,25 +739,49 @@ export class AnthropicProvider implements Provider {
       // — the API accepts them. No provider-side stripping needed.
 
       sentMessages = ensureToolPairing(repairOrphanedServerToolUse(formatted));
-      const { effort, speed, output_config, cacheTtl: _cacheTtl, ...restConfig } = (config ??
-        {}) as Record<string, unknown> & {
+      const {
+        effort,
+        speed,
+        output_config,
+        cacheTtl: _cacheTtl,
+        max_tokens: callerMaxTokens,
+        ...restConfig
+      } = (config ?? {}) as Record<string, unknown> & {
         effort?: Anthropic.OutputConfig["effort"];
         speed?: "standard" | "fast";
         output_config?: Record<string, unknown>;
       };
-      // Haiku does not support the effort / output_config parameter.
+      // Haiku does not support the effort / output_config parameter,
+      // extended cache TTL betas, 1M context, or 64K output tokens.
       // Determine the effective model (per-call override or provider default)
-      // and strip effort when the model doesn't support it.
+      // and gate features accordingly.
       const effectiveModel =
         (restConfig as Record<string, unknown>).model?.toString() ?? this.model;
-      const supportsEffort = !effectiveModel.includes("haiku");
+      const isHaiku = effectiveModel.includes("haiku");
+      const supportsEffort = !isHaiku;
       const mergedOutputConfig = {
         ...(output_config ?? {}),
         ...(effort && supportsEffort ? { effort } : {}),
       };
-      const params: Anthropic.MessageStreamParams = {
+      // Build cache_control objects: Haiku doesn't support the extended
+      // cache TTL beta, so omit the ttl field for Haiku models.
+      const cacheControl = isHaiku
+        ? { type: "ephemeral" as const }
+        : { type: "ephemeral" as const, ttl: cacheTtl };
+      const tailCacheControl = isHaiku
+        ? { type: "ephemeral" as const }
+        : { type: "ephemeral" as const, ttl: "5m" as const };
+
+      let params: Anthropic.MessageStreamParams = {
         model: this.model,
-        max_tokens: 64000,
+        max_tokens: isHaiku
+          ? Math.min(
+              typeof callerMaxTokens === "number" ? callerMaxTokens : 8192,
+              8192,
+            )
+          : typeof callerMaxTokens === "number"
+            ? callerMaxTokens
+            : 64000,
         messages: sentMessages,
         ...restConfig,
         ...(Object.keys(mergedOutputConfig).length > 0
@@ -733,12 +807,12 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: staticBlock,
-              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
+              cache_control: cacheControl,
             },
             {
               type: "text" as const,
               text: dynamicBlock,
-              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
+              cache_control: cacheControl,
             },
           ];
         } else {
@@ -746,7 +820,7 @@ export class AnthropicProvider implements Provider {
             {
               type: "text" as const,
               text: systemPrompt,
-              cache_control: { type: "ephemeral" as const, ttl: cacheTtl },
+              cache_control: cacheControl,
             },
           ];
         }
@@ -763,12 +837,7 @@ export class AnthropicProvider implements Provider {
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
             ...(i === otherTools.length - 1
-              ? {
-                  cache_control: {
-                    type: "ephemeral" as const,
-                    ttl: cacheTtl,
-                  },
-                }
+              ? { cache_control: cacheControl }
               : {}),
           }));
           const webSearchTool: Anthropic.WebSearchTool20250305 = {
@@ -782,14 +851,7 @@ export class AnthropicProvider implements Provider {
             name: t.name,
             description: t.description,
             input_schema: t.input_schema as Anthropic.Tool["input_schema"],
-            ...(i === tools.length - 1
-              ? {
-                  cache_control: {
-                    type: "ephemeral" as const,
-                    ttl: cacheTtl,
-                  },
-                }
-              : {}),
+            ...(i === tools.length - 1 ? { cache_control: cacheControl } : {}),
           }));
         }
       }
@@ -813,10 +875,8 @@ export class AnthropicProvider implements Provider {
         if (!hasText) continue;
         const lastBlock = msg.content[msg.content.length - 1];
         if (typeof lastBlock !== "string") {
-          (lastBlock as unknown as Record<string, unknown>).cache_control = {
-            type: "ephemeral",
-            ttl: cacheTtl,
-          };
+          (lastBlock as unknown as Record<string, unknown>).cache_control =
+            cacheControl;
         }
         turnStartIdx = i;
         break;
@@ -832,7 +892,10 @@ export class AnthropicProvider implements Provider {
       if (turnStartIdx >= 0 && turnStartIdx < sentMessages.length - 1) {
         const lastMsg = sentMessages[sentMessages.length - 1];
         if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
-          const NON_CACHEABLE_TYPES = new Set(["thinking", "redacted_thinking"]);
+          const NON_CACHEABLE_TYPES = new Set([
+            "thinking",
+            "redacted_thinking",
+          ]);
           let tailBlock: (typeof lastMsg.content)[number] | undefined;
           for (let j = lastMsg.content.length - 1; j >= 0; j--) {
             const block = lastMsg.content[j];
@@ -845,10 +908,8 @@ export class AnthropicProvider implements Provider {
             }
           }
           if (tailBlock && typeof tailBlock !== "string") {
-            (tailBlock as unknown as Record<string, unknown>).cache_control = {
-              type: "ephemeral",
-              ttl: "5m",
-            };
+            (tailBlock as unknown as Record<string, unknown>).cache_control =
+              tailCacheControl;
             tailBreakpointApplied = true;
           }
         }
@@ -872,7 +933,17 @@ export class AnthropicProvider implements Provider {
         params.system.length === 2 &&
         hasToolCacheBreakpoint
       ) {
-        delete (params.system[0] as unknown as Record<string, unknown>).cache_control;
+        delete (params.system[0] as unknown as Record<string, unknown>)
+          .cache_control;
+      }
+
+      // Strip orphaned UTF-16 surrogates so the Anthropic JSON parser never
+      // sees invalid strings produced by upstream surrogate-splitting `.slice()` calls.
+      const sanitized = stripOrphanedSurrogatesDeep(params);
+      if (sanitized.changed) {
+        logOrphanedSurrogateWarning(sanitized.fixedStringCount, sentMessages);
+        params = sanitized.value;
+        sentMessages = params.messages;
       }
 
       const { signal: timeoutSignal, cleanup: cleanupTimeout } =
@@ -890,15 +961,15 @@ export class AnthropicProvider implements Provider {
         finalMessage(): Promise<Anthropic.Message>;
       }
 
-      // Fast mode: use the beta endpoint with speed: "fast" for Opus 4.6
+      // Fast mode: use the beta endpoint with speed: "fast" for Opus models (4.6, 4.7)
       const useFastMode = speed === "fast" && effectiveModel.includes("opus");
 
       // Collect required betas: extended cache TTL for 1h system prompt caching,
       // 1M context window, and fast-mode when applicable.
-      const betas: string[] = [
-        "extended-cache-ttl-2025-04-11",
-        "context-1m-2025-08-07",
-      ];
+      // Haiku doesn't support the extended cache TTL or 1M context betas.
+      const betas: string[] = isHaiku
+        ? []
+        : ["extended-cache-ttl-2025-04-11", "context-1m-2025-08-07"];
       if (useFastMode) {
         betas.push("fast-mode-2026-02-01");
       }
@@ -915,14 +986,18 @@ export class AnthropicProvider implements Provider {
                 Anthropic.Beta.Messages.MessageCreateParamsStreaming,
               { signal: timeoutSignal },
             ) as unknown as UnifiedStream)
-          : (this.client.beta.messages.stream(
-              {
-                ...(params as Record<string, unknown>),
-                betas,
-              } as Anthropic.Beta.Messages.MessageCreateParamsNonStreaming &
-                Anthropic.Beta.Messages.MessageCreateParamsStreaming,
-              { signal: timeoutSignal },
-            ) as unknown as UnifiedStream);
+          : betas.length > 0
+            ? (this.client.beta.messages.stream(
+                {
+                  ...(params as Record<string, unknown>),
+                  betas,
+                } as Anthropic.Beta.Messages.MessageCreateParamsNonStreaming &
+                  Anthropic.Beta.Messages.MessageCreateParamsStreaming,
+                { signal: timeoutSignal },
+              ) as unknown as UnifiedStream)
+            : (this.client.messages.stream(params, {
+                signal: timeoutSignal,
+              }) as unknown as UnifiedStream);
 
         stream.on("text", (text) => {
           onEvent?.({ type: "text_delta", text });
@@ -982,6 +1057,9 @@ export class AnthropicProvider implements Provider {
               type: "server_tool_complete",
               toolUseId: block.tool_use_id,
               isError: !!isError,
+              ...(Array.isArray(block.content)
+                ? { content: block.content }
+                : {}),
             });
           }
           if (event.type === "content_block_stop") {
@@ -1063,6 +1141,12 @@ export class AnthropicProvider implements Provider {
         rawResponse: response,
       };
     } catch (error) {
+      // Propagate a tagged AbortReason (set by the daemon at controller.abort())
+      // so wrapped errors can be classified as user cancellation downstream.
+      const abortReason =
+        signal?.aborted && isAbortReason(signal.reason)
+          ? signal.reason
+          : undefined;
       if (error instanceof Anthropic.APIError) {
         // Log detailed message structure for tool_use/tool_result ordering errors
         if (
@@ -1078,20 +1162,33 @@ export class AnthropicProvider implements Provider {
             "Anthropic 400: tool_use/tool_result pairing error — dumping message structure",
           );
         }
-        log.error(
-          {
-            status: error.status,
-            message: error.message,
-            headers: Object.fromEntries(error.headers?.entries() ?? []),
-          },
-          `Anthropic API error (${error.status})`,
-        );
+        if (abortReason) {
+          log.info(
+            { abortReason, message: error.message },
+            "Anthropic request aborted by daemon",
+          );
+        } else {
+          log.error(
+            {
+              status: error.status,
+              message: error.message,
+              headers: Object.fromEntries(error.headers?.entries() ?? []),
+            },
+            `Anthropic API error (${error.status})`,
+          );
+        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
+        const errorOptions: {
+          retryAfterMs?: number;
+          abortReason?: unknown;
+        } = {};
+        if (retryAfterMs !== undefined) errorOptions.retryAfterMs = retryAfterMs;
+        if (abortReason) errorOptions.abortReason = abortReason;
         throw new ProviderError(
           `Anthropic API error (${error.status}): ${error.message}`,
           "anthropic",
           error.status,
-          retryAfterMs !== undefined ? { retryAfterMs } : undefined,
+          Object.keys(errorOptions).length > 0 ? errorOptions : undefined,
         );
       }
       throw new ProviderError(
@@ -1100,7 +1197,7 @@ export class AnthropicProvider implements Provider {
         }`,
         "anthropic",
         undefined,
-        { cause: error },
+        abortReason ? { cause: error, abortReason } : { cause: error },
       );
     }
   }

package/src/providers/fireworks/client.ts

@@ -1,4 +1,4 @@
-import { OpenAIProvider } from "../openai/client.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 
 export interface FireworksProviderOptions {
   apiKey?: string;
@@ -8,7 +8,7 @@ export interface FireworksProviderOptions {
 
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
-export class FireworksProvider extends OpenAIProvider {
+export class FireworksProvider extends OpenAIChatCompletionsProvider {
   constructor(
     apiKey: string,
     model: string,