@vellumai/assistant 0.8.5 → 0.8.7

package/src/context/tool-result-truncation.ts

@@ -1,9 +1,9 @@
+import { truncateToolResultText } from "../plugins/defaults/tool-result-truncate/terminal.js";
 import type {
   ContentBlock,
   Message,
   ToolResultContent,
 } from "../providers/types.js";
-import { safeStringSlice } from "../util/unicode.js";
 
 /**
  * Maximum share of the context window that a single tool result may occupy.
@@ -15,48 +15,6 @@ const MAX_TOOL_RESULT_CONTEXT_SHARE = 0.3;
  */
 export const HARD_MAX_TOOL_RESULT_CHARS = 400_000;
 
-/**
- * Minimum number of characters to preserve when truncating.
- */
-export const MIN_KEEP_CHARS = 2_000;
-
-/**
- * Suffix appended to truncated tool results.
- */
-export const TRUNCATION_SUFFIX =
-  "\n\n[Content truncated — original exceeded size limit. Use offset/limit parameters or request specific sections for large content.]";
-
-/**
- * Truncate text with newline-boundary awareness.
- *
- * If `text.length <= maxChars`, the text is returned as-is.
- * Otherwise we look for the last newline that falls within 80% of the budget
- * so we get a clean cut. At least `MIN_KEEP_CHARS` characters are always
- * preserved.
- */
-export function truncateToolResultText(text: string, maxChars: number): string {
-  if (text.length <= maxChars) {
-    return text;
-  }
-
-  const effectiveMax = Math.max(maxChars, MIN_KEEP_CHARS);
-  const cutPoint = effectiveMax - TRUNCATION_SUFFIX.length;
-
-  // Look for a newline within the last 20% of the budget for a clean break.
-  const threshold = Math.floor(cutPoint * 0.8);
-  const lastNewline = text.lastIndexOf("\n", cutPoint);
-
-  const sliceEnd = lastNewline >= threshold ? lastNewline : cutPoint;
-
-  // If sliceEnd covers the full text, nothing was actually removed — return
-  // the original text without appending the suffix.
-  if (sliceEnd >= text.length) {
-    return text;
-  }
-
-  return safeStringSlice(text, 0, sliceEnd) + TRUNCATION_SUFFIX;
-}
-
 /**
  * Calculate the maximum allowed characters for a tool result based on the
  * context window size. Uses ~4 chars per token as a rough heuristic.

package/src/context/window-manager.ts

@@ -24,6 +24,7 @@ import type {
   Provider,
   ToolDefinition,
 } from "../providers/types.js";
+import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import {
   type CompactionRunArgs,
@@ -68,6 +69,19 @@ export interface ContextWindowResult {
   summaryText: string;
   reason?: string;
   summaryFailed?: boolean;
+  /**
+   * Set to `true` when {@link ContextWindowManager.maybeCompact} ran the
+   * compactor up to `overflowRecovery.maxAttempts` times and still could
+   * not reduce the estimated input tokens below the auto-threshold (or a
+   * single attempt produced no token reduction at all). Callers that
+   * orchestrate mid-loop compaction use this as the "give up, escalate"
+   * signal — there's no point retrying the compactor again; reducers
+   * (truncation / media stubbing) need to step in.
+   *
+   * Omitted (treated as `false`) on no-op early returns and on successful
+   * compactions that did clear the threshold.
+   */
+  exhausted?: boolean;
 }
 
 export interface ShouldCompactResult {
@@ -98,6 +112,12 @@ export interface ContextWindowCompactOptions {
   minKeepRecentUserTurns?: number;
   conversationOriginChannel?: string;
   targetInputTokensOverride?: number;
+  /**
+   * Trust class of the actor whose turn triggered compaction. Forwarded to
+   * the compactor so the image manifest excludes guardian-only attachments
+   * for untrusted actors.
+   */
+  actorTrustClass?: TrustClass;
 }
 
 export interface ContextWindowManagerOptions {
@@ -322,7 +342,7 @@ export class ContextWindowManager {
       });
     }
 
-    const args: CompactionRunArgs = {
+    const baseArgs: CompactionRunArgs = {
       conversationId: this.conversationId,
       messages,
       provider: this.provider,
@@ -334,44 +354,104 @@ export class ContextWindowManager {
       force: options?.force,
       signal,
       overrideProfile: options?.overrideProfile ?? null,
+      actorTrustClass: options?.actorTrustClass,
       nonPersistedPrefixCount: this.nonPersistedPrefixCount,
     };
 
-    const result = await runAssistantDrivenCompaction(args);
+    // Retry budget for the compactor itself. Lives here (not in the
+    // orchestrator/agent loop) because the question "did this compactor
+    // make enough progress?" is a compaction-internal concern. The agent
+    // loop only needs to know the binary outcome — drop below threshold,
+    // or signal `exhausted` so reducers escalate.
+    const maxAttempts = this.config.overflowRecovery.maxAttempts;
+
+    let result = await runAssistantDrivenCompaction(baseArgs);
 
+    // Compactor early-returned without doing any work (e.g. no eligible
+    // messages, summary failed, disabled mid-way). Nothing to retry.
     if (!result.compacted) return result;
 
-    // Recompute the post-compaction token estimate now that the message
-    // array has been rebuilt. The compactor returns a conservative
-    // placeholder; the agent loop wants the real number for its next
-    // budget decision.
-    let estimatedInputTokens = result.estimatedInputTokens;
-    try {
-      estimatedInputTokens = estimatePromptTokens(
-        result.messages,
-        this.systemPrompt,
-        {
-          providerName: this.estimationProviderName,
-          toolTokenBudget: this.toolTokenBudget,
-        },
+    let estimatedInputTokens = this.recomputePostCompactionEstimate(
+      result.messages,
+      result.estimatedInputTokens,
+    );
+    this.consumeCompactionState(result.compactedMessages);
+
+    // If a single pass already cleared the auto-threshold, ship it.
+    if (estimatedInputTokens < thresholdTokens) {
+      return { ...result, estimatedInputTokens };
+    }
+
+    // Still above the threshold after one pass — retry on the compacted
+    // history, up to the remaining budget. Each retry runs against the
+    // PREVIOUS attempt's output, building a tighter summary each time.
+    // Bail early as soon as a pass fails to reduce — that's a stuck
+    // compactor and another attempt won't help.
+    let previousEstimate = estimatedInputTokens;
+    for (let attempt = 2; attempt <= maxAttempts; attempt++) {
+      const nextResult = await runAssistantDrivenCompaction({
+        ...baseArgs,
+        messages: result.messages,
+        previousEstimatedInputTokens: previousEstimate,
+        nonPersistedPrefixCount: this.nonPersistedPrefixCount,
+      });
+      if (!nextResult.compacted) break;
+      const nextEstimate = this.recomputePostCompactionEstimate(
+        nextResult.messages,
+        nextResult.estimatedInputTokens,
       );
+      this.consumeCompactionState(nextResult.compactedMessages);
+      result = mergeCompactionResults(result, nextResult);
+      estimatedInputTokens = nextEstimate;
+      if (estimatedInputTokens < thresholdTokens) {
+        return { ...result, estimatedInputTokens };
+      }
+      // Non-productive (compacted but didn't shrink) — stuck compactor.
+      if (estimatedInputTokens >= previousEstimate) break;
+      previousEstimate = estimatedInputTokens;
+    }
+
+    // Out of attempts or stuck — surface `exhausted` so the orchestrator
+    // can escalate to reducer tiers instead of re-running the compactor.
+    return { ...result, estimatedInputTokens, exhausted: true };
+  }
+
+  /**
+   * Recompute the prompt-token estimate against the post-compaction
+   * message array. The compactor returns a conservative placeholder; the
+   * orchestrator needs the real number for its next budget decision.
+   */
+  private recomputePostCompactionEstimate(
+    messages: Message[],
+    fallback: number,
+  ): number {
+    try {
+      return estimatePromptTokens(messages, this.systemPrompt, {
+        providerName: this.estimationProviderName,
+        toolTokenBudget: this.toolTokenBudget,
+      });
     } catch (err) {
       log.warn({ err }, "Post-compaction token estimate failed");
+      return fallback;
     }
+  }
 
-    // Consume any non-persisted prefix messages that were compacted away
-    // and clear the injected-summary flag.
+  /**
+   * Decrement the non-persisted prefix bookkeeping and clear the
+   * injected-summary flag after a productive compaction. Called once per
+   * successful internal attempt so multi-attempt runs keep the count
+   * honest as the leading injected messages get folded into the summary.
+   */
+  private consumeCompactionState(compactedMessages: number): void {
     const compactedAway = Math.min(
       this.nonPersistedPrefixCount,
-      result.compactedMessages,
+      compactedMessages,
     );
     this.nonPersistedPrefixCount = Math.max(
       0,
       this.nonPersistedPrefixCount - compactedAway,
     );
     this.summaryIsInjected = false;
-
-    return { ...result, estimatedInputTokens };
   }
 }
 
@@ -379,6 +459,44 @@ export class ContextWindowManager {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Combine the result of a follow-up compaction attempt with the running
+ * aggregate so the orchestrator sees cumulative work — total messages
+ * folded into the summary, total summary LLM calls, total token spend —
+ * across all internal retries. Content fields (the new messages array,
+ * latest summary text, latest estimate) take the `next` attempt's value.
+ */
+function mergeCompactionResults(
+  prev: ContextWindowResult,
+  next: ContextWindowResult,
+): ContextWindowResult {
+  return {
+    ...next,
+    previousEstimatedInputTokens: prev.previousEstimatedInputTokens,
+    compactedMessages: prev.compactedMessages + next.compactedMessages,
+    compactedPersistedMessages:
+      prev.compactedPersistedMessages + next.compactedPersistedMessages,
+    summaryCalls: prev.summaryCalls + next.summaryCalls,
+    summaryInputTokens: prev.summaryInputTokens + next.summaryInputTokens,
+    summaryOutputTokens: prev.summaryOutputTokens + next.summaryOutputTokens,
+    summaryCacheCreationInputTokens:
+      (prev.summaryCacheCreationInputTokens ?? 0) +
+      (next.summaryCacheCreationInputTokens ?? 0),
+    summaryCacheReadInputTokens:
+      (prev.summaryCacheReadInputTokens ?? 0) +
+      (next.summaryCacheReadInputTokens ?? 0),
+    summaryRawResponses: [
+      ...(prev.summaryRawResponses ?? []),
+      ...(next.summaryRawResponses ?? []),
+    ],
+    // Any failure across attempts taints the run for the circuit breaker.
+    summaryFailed:
+      next.summaryFailed === true || prev.summaryFailed === true
+        ? true
+        : (next.summaryFailed ?? prev.summaryFailed),
+  };
+}
+
 function noopResult(
   messages: Message[],
   estimated: number,

package/src/credential-execution/executable-discovery.ts

@@ -212,3 +212,43 @@ export function discoverCes(): DiscoveryResult {
   }
   return discoverLocalCes();
 }
+
+/** How long to poll for the managed bootstrap socket before giving up. */
+const MANAGED_DISCOVERY_TIMEOUT_MS = 3_000;
+
+/** Delay between managed bootstrap-socket discovery attempts. */
+const MANAGED_DISCOVERY_INTERVAL_MS = 100;
+
+/**
+ * Discover CES, polling for the managed bootstrap socket with a short
+ * backoff before failing.
+ *
+ * The managed CES sidecar re-binds its bootstrap socket after each assistant
+ * session ends — it outlives any single assistant and accepts the next
+ * connection (see `credential-executor/src/managed-main.ts`). A reconnecting
+ * assistant (e.g. after a container restart) can therefore probe during the
+ * brief window before the socket is re-bound. A single existence check would
+ * race that window and incorrectly report the sidecar as unavailable; polling
+ * absorbs the gap.
+ *
+ * Local discovery is returned immediately — a missing binary will not appear
+ * by waiting, so there is nothing to poll for.
+ */
+export async function discoverCesWithRetry({
+  timeoutMs = MANAGED_DISCOVERY_TIMEOUT_MS,
+  intervalMs = MANAGED_DISCOVERY_INTERVAL_MS,
+}: { timeoutMs?: number; intervalMs?: number } = {}): Promise<DiscoveryResult> {
+  // Only the managed bootstrap socket is worth polling for; a missing local
+  // binary will not appear by waiting.
+  if (!getIsContainerized()) {
+    return discoverCes();
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  let result = discoverCes();
+  while (result.mode === "unavailable" && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    result = discoverCes();
+  }
+  return result;
+}

package/src/credential-execution/process-manager.ts

@@ -29,7 +29,7 @@ import { ensureBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
 import type { CesTransport } from "./client.js";
 import {
-  discoverCes,
+  discoverCesWithRetry,
   discoverLocalCes,
   type DiscoveryResult,
   type LocalDiscoverySuccess,
@@ -118,7 +118,11 @@ export function createCesProcessManager(
         throw new Error("CES process manager is already running");
       }
 
-      discoveryResult = await discoverCes();
+      // Poll for the managed bootstrap socket with a short backoff. The CES
+      // sidecar re-binds its socket after each assistant session ends, so a
+      // reconnecting assistant can briefly race the re-bind; a single probe
+      // would otherwise fall back to local discovery and fail in managed mode.
+      discoveryResult = await discoverCesWithRetry();
       if (discoveryResult.mode === "unavailable") {
         // The managed sidecar bootstrap socket is not present — this happens
         // when the instance pre-dates the socket volume mount (e.g. existing

package/src/credential-health/credential-health-service.ts

@@ -7,8 +7,10 @@
  * - Scope coverage (grantedScopes vs provider defaultScopes)
  * - Liveness ping (for providers with a pingUrl)
  *
- * Designed to run during the heartbeat cycle. All checks are diagnostic —
- * no token refresh or recovery is attempted.
+ * Designed to run during the heartbeat cycle. The BYO liveness ping is
+ * routed through `withValidToken`, so a stale-but-refreshable access token
+ * is refreshed transparently before the ping fires — this prevents the
+ * heartbeat from misreporting a refreshable connection as `"revoked"`.
  */
 
 import { isTokenExpired } from "@vellumai/credential-storage";
@@ -22,6 +24,10 @@ import {
   type OAuthConnectionRow,
   type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
+import {
+  TokenExpiredError,
+  withValidToken,
+} from "../security/token-manager.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("credential-health");
@@ -125,6 +131,45 @@ async function pingProvider(
   }
 }
 
+/**
+ * Map a pingProvider result onto a CredentialHealthResult, or null when the
+ * ping succeeded. `authErrorContext` distinguishes whether a 401/403 came
+ * after a refresh attempt (refreshable connection) or directly from the
+ * stored token (manual-token / no-refresh connection) — the latter is the
+ * historical message wording.
+ */
+type PingFailureContext = "after_refresh" | "no_refresh";
+
+function pingResultToHealthFailure(
+  base: Omit<CredentialHealthResult, "status" | "details" | "canAutoRecover">,
+  provider: string,
+  connectionId: string,
+  pingResult: { ok: boolean; authError: boolean },
+  authErrorContext: PingFailureContext,
+): CredentialHealthResult | null {
+  if (pingResult.ok) return null;
+  if (pingResult.authError) {
+    const suffix =
+      authErrorContext === "after_refresh" ? " after a refresh attempt" : "";
+    return {
+      ...base,
+      status: "revoked",
+      details: `${provider} token was rejected (401/403)${suffix}. The token may have been revoked. Re-authorization required.`,
+      canAutoRecover: false,
+    };
+  }
+  log.debug(
+    { provider, connectionId },
+    "Credential ping failed with non-auth error",
+  );
+  return {
+    ...base,
+    status: "ping_failed",
+    details: `${provider} liveness check failed (non-auth error). This may be transient.`,
+    canAutoRecover: false,
+  };
+}
+
 // ── Core check ────────────────────────────────────────────────────────
 
 interface CheckConnectionOpts {
@@ -192,14 +237,18 @@ async function checkConnection(
   const token = tokenResult.value;
 
   // 2. Check token expiry
-  if (isTokenExpired(expiresAt)) {
+  //
+  // When the token is expired AND there is no refresh token, we have no path
+  // to recovery — short-circuit to "expired". When there IS a refresh token,
+  // we fall through so the ping (via withValidToken) can attempt a refresh
+  // and confirm whether the refresh token still works. Without that, we'd
+  // return "expiring" speculatively even when the refresh token was revoked.
+  if (isTokenExpired(expiresAt) && !hasRefreshToken) {
     return {
       ...base,
-      status: hasRefreshToken ? "expiring" : "expired",
-      details: hasRefreshToken
-        ? `Token for ${provider} is expired but has a refresh token — auto-recovery may work.`
-        : `Token for ${provider} is expired with no refresh token. Re-authorization required.`,
-      canAutoRecover: hasRefreshToken,
+      status: "expired",
+      details: `Token for ${provider} is expired with no refresh token. Re-authorization required.`,
+      canAutoRecover: false,
     };
   }
 
@@ -234,36 +283,51 @@ async function checkConnection(
   }
 
   // 4. Liveness ping
+  //
+  // For refreshable connections we route through withValidToken so an
+  // expired-but-refreshable token gets refreshed before the ping fires.
+  // Without this wrapping, the ping would hit 401 on a stale token and the
+  // connection would be misreported as "revoked" — even though the next real
+  // API call (which goes through BYOOAuthConnection.request → withValidToken)
+  // would have refreshed and succeeded.
   if (pingUrl) {
-    const pingResult = await pingProvider(
-      token,
-      pingUrl,
-      pingMethod,
-      pingHeaders,
-      pingBody,
-    );
-    if (!pingResult.ok) {
-      if (pingResult.authError) {
-        return {
-          ...base,
-          status: "revoked",
-          details: `${provider} token was rejected (401/403). The token may have been revoked. Re-authorization required.`,
-          canAutoRecover: false,
-        };
+    const runPing = (t: string) =>
+      pingProvider(t, pingUrl, pingMethod, pingHeaders, pingBody);
+
+    let pingResult: { ok: boolean; authError: boolean };
+    let authContext: PingFailureContext;
+
+    if (hasRefreshToken) {
+      try {
+        pingResult = await withValidToken(provider, runPing, { connectionId });
+      } catch (err) {
+        if (err instanceof TokenExpiredError) {
+          // Refresh itself failed (revoked refresh token, invalid_grant, etc.)
+          return {
+            ...base,
+            status: "revoked",
+            details: `${provider} token refresh failed. The refresh token may have been revoked. Re-authorization required.`,
+            canAutoRecover: false,
+          };
+        }
+        throw err;
       }
-      // Non-auth ping failure — log but don't mark as critical.
-      // Could be a transient API issue.
-      log.debug(
-        { provider, connectionId },
-        "Credential ping failed with non-auth error",
-      );
-      return {
-        ...base,
-        status: "ping_failed",
-        details: `${provider} liveness check failed (non-auth error). This may be transient.`,
-        canAutoRecover: false,
-      };
+      authContext = "after_refresh";
+    } else {
+      // Manual-token provider or an OAuth provider whose initial flow
+      // didn't return a refresh_token — nothing to refresh, ping directly.
+      pingResult = await runPing(token);
+      authContext = "no_refresh";
     }
+
+    const failure = pingResultToHealthFailure(
+      base,
+      provider,
+      connectionId,
+      pingResult,
+      authContext,
+    );
+    if (failure) return failure;
   }
 
   return {
@@ -434,10 +498,28 @@ async function checkManagedProvider(
             canAutoRecover: true,
           });
         } else if (pingResp.status === 401 || pingResp.status === 403) {
+          // 401/403 from the upstream provider after the platform proxy
+          // forwarded the request. From the daemon side we can't tell
+          // whether the proxy attempted (and failed) a refresh-before-
+          // forward or skipped refresh entirely and forwarded a stale token.
+          // Either way it's not definitively unrecoverable — the next ping
+          // cycle may succeed if the platform re-refreshes. Demote to
+          // ping_failed so we don't fire a user-facing reconnect alert on
+          // what may be a transient platform-side miss. Only platform-
+          // attested 424 (CredentialRequiredError below) signals genuine
+          // unrecoverable failure.
+          log.debug(
+            {
+              provider: providerRow.provider,
+              connectionId: conn.id,
+              status: pingResp.status,
+            },
+            "Managed credential ping returned 401/403 — treating as potentially transient",
+          );
           results.push({
             ...base,
-            status: "revoked",
-            details: `${providerRow.provider} managed token was rejected (${pingResp.status}). Reconnect on the Vellum platform.`,
+            status: "ping_failed",
+            details: `${providerRow.provider} managed liveness check returned ${pingResp.status} from the upstream provider. The Vellum platform may not have refreshed the token before forwarding; will retry next cycle.`,
             canAutoRecover: false,
           });
         } else {
@@ -450,8 +532,11 @@ async function checkManagedProvider(
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        // CredentialRequiredError means the platform can't materialize
-        // the token — treat as revoked.
+        // CredentialRequiredError corresponds to a 424 from the platform
+        // proxy — the platform attempted (and gave up on) refresh and is
+        // telling us the credential is genuinely unrecoverable. This is
+        // the only managed-path signal we trust enough to fire a user-
+        // facing reconnect alert.
         if (
           err &&
           typeof err === "object" &&
@@ -461,7 +546,7 @@ async function checkManagedProvider(
           results.push({
             ...base,
             status: "revoked",
-            details: `${providerRow.provider} managed connection is no longer valid. Reconnect on the Vellum platform.`,
+            details: `${providerRow.provider} managed connection cannot be refreshed by the Vellum platform. Reconnect on the Vellum platform.`,
             canAutoRecover: false,
           });
         } else {

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -26,12 +26,9 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { createMockLoggerModule } from "../../__tests__/helpers/mock-logger.js";
+
+mock.module("../../util/logger.js", () => createMockLoggerModule());
 
 // ---------------------------------------------------------------------------
 // Mock state — reset between tests.