@vellumai/assistant 0.4.51 → 0.4.53

package/src/daemon/handlers/skills.ts

@@ -9,12 +9,7 @@ import {
   saveRawConfig,
 } from "../../config/loader.js";
 import { resolveSkillStates, skillFlagKey } from "../../config/skill-state.js";
-import {
-  ensureSkillIcon,
-  loadSkillBySelector,
-  loadSkillCatalog,
-  type SkillSummary,
-} from "../../config/skills.js";
+import { loadSkillCatalog, type SkillSummary } from "../../config/skills.js";
 import {
   createTimeout,
   extractText,
@@ -36,20 +31,6 @@ import {
   validateManagedSkillId,
 } from "../../skills/managed-store.js";
 import { getWorkspaceSkillsDir } from "../../util/platform.js";
-import type {
-  SkillDetailRequest,
-  SkillsCheckUpdatesRequest,
-  SkillsConfigureRequest,
-  SkillsCreateRequest,
-  SkillsDisableRequest,
-  SkillsDraftRequest,
-  SkillsEnableRequest,
-  SkillsInspectRequest,
-  SkillsInstallRequest,
-  SkillsSearchRequest,
-  SkillsUninstallRequest,
-  SkillsUpdateRequest,
-} from "../message-protocol.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
   ensureSkillEntry,
@@ -782,183 +763,3 @@ export async function createSkill(
     return { success: false, error: message };
   }
 }
-
-// ─── HTTP handlers (thin wrappers) ──────────────────────────────────────────
-
-export function handleSkillsList(ctx: HandlerContext): void {
-  const skills = listSkills(ctx);
-  ctx.send({ type: "skills_list_response", skills });
-}
-
-export function handleSkillsEnable(
-  msg: SkillsEnableRequest,
-  ctx: HandlerContext,
-): void {
-  const result = enableSkill(msg.name, ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "enable",
-    ...result,
-  });
-}
-
-export function handleSkillsDisable(
-  msg: SkillsDisableRequest,
-  ctx: HandlerContext,
-): void {
-  const result = disableSkill(msg.name, ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "disable",
-    ...result,
-  });
-}
-
-export function handleSkillsConfigure(
-  msg: SkillsConfigureRequest,
-  ctx: HandlerContext,
-): void {
-  const result = configureSkill(
-    msg.name,
-    { env: msg.env, apiKey: msg.apiKey, config: msg.config },
-    ctx,
-  );
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "configure",
-    ...result,
-  });
-}
-
-export async function handleSkillsInstall(
-  msg: SkillsInstallRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await installSkill(
-    { slug: msg.slug, version: msg.version },
-    ctx,
-  );
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "install",
-    ...result,
-  });
-}
-
-export async function handleSkillsUninstall(
-  msg: SkillsUninstallRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await uninstallSkill(msg.name, ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "uninstall",
-    ...result,
-  });
-}
-
-export async function handleSkillsUpdate(
-  msg: SkillsUpdateRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await updateSkill(msg.name, ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "update",
-    ...result,
-  });
-}
-
-export async function handleSkillsCheckUpdates(
-  _msg: SkillsCheckUpdatesRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await checkSkillUpdates(ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "check_updates",
-    ...result,
-  });
-}
-
-export async function handleSkillsSearch(
-  msg: SkillsSearchRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await searchSkills(msg.query, ctx);
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "search",
-    ...result,
-  });
-}
-
-export async function handleSkillsInspect(
-  msg: SkillsInspectRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await inspectSkill(msg.slug, ctx);
-  ctx.send({
-    type: "skills_inspect_response",
-    ...result,
-  });
-}
-
-export async function handleSkillDetail(
-  msg: SkillDetailRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = loadSkillBySelector(msg.skillId);
-  if (result.skill) {
-    const icon = await ensureSkillIcon(
-      result.skill.directoryPath,
-      result.skill.displayName,
-      result.skill.description,
-    );
-    ctx.send({
-      type: "skill_detail_response",
-      skillId: result.skill.id,
-      body: result.skill.body,
-      ...(icon ? { icon } : {}),
-    });
-  } else {
-    ctx.send({
-      type: "skill_detail_response",
-      skillId: msg.skillId,
-      body: "",
-      error: result.error ?? "Skill not found",
-    });
-  }
-}
-
-export async function handleSkillsDraft(
-  msg: SkillsDraftRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await draftSkill({ sourceText: msg.sourceText }, ctx);
-  ctx.send({ type: "skills_draft_response", ...result });
-}
-
-export async function handleSkillsCreate(
-  msg: SkillsCreateRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const result = await createSkill(
-    {
-      skillId: msg.skillId,
-      name: msg.name,
-      description: msg.description,
-      emoji: msg.emoji,
-      bodyMarkdown: msg.bodyMarkdown,
-      userInvocable: msg.userInvocable,
-      disableModelInvocation: msg.disableModelInvocation,
-      overwrite: msg.overwrite,
-    },
-    ctx,
-  );
-  ctx.send({
-    type: "skills_operation_response",
-    operation: "create",
-    ...result,
-  });
-}

package/src/daemon/lifecycle.ts

@@ -177,15 +177,17 @@ export async function runDaemon(): Promise<void> {
     }
     log.info("Daemon startup: DB initialized");
 
-    // Expire any pending canonical guardian requests left over from before
-    // this process started.  Their in-memory pending-interaction session
-    // references are gone, so they can never be completed.  The agent loop
-    // will re-request tool approvals on the next turn.
+    // Expire pending interaction-bound canonical guardian requests left over
+    // from before this process started.  Their in-memory pending-interaction
+    // session references are gone, so they can never be completed.  Only
+    // interaction-bound kinds (tool_approval, pending_question) are expired;
+    // persistent kinds (access_request, tool_grant_request) remain valid
+    // across restarts.
     const expiredCount = expireAllPendingCanonicalRequests();
     if (expiredCount > 0) {
       log.info(
         { event: "startup_expired_stale_requests", expiredCount },
-        `Expired ${expiredCount} stale pending canonical request(s) from previous process`,
+        `Expired ${expiredCount} stale interaction-bound canonical request(s) from previous process`,
       );
     }
 
@@ -421,6 +423,7 @@ export async function runDaemon(): Promise<void> {
             scheduleId: schedule.id,
             name: schedule.name,
           },
+          dedupeKey: `schedule:complete:${schedule.id}:${Date.now()}`,
         });
       },
       (notification) => {

package/src/daemon/message-types/contacts.ts

@@ -58,6 +58,8 @@ export interface ContactChannelPayload {
   verifiedAt?: number;
   verifiedVia?: string;
   lastSeenAt?: number;
+  interactionCount?: number;
+  lastInteraction?: number;
   revokedReason?: string;
   blockedReason?: string;
 }

package/src/daemon/message-types/integrations.ts

@@ -120,6 +120,7 @@ export interface TelegramConfigResponse {
   type: "telegram_config_response";
   success: boolean;
   hasBotToken: boolean;
+  botId?: string;
   botUsername?: string;
   connected: boolean;
   hasWebhookSecret: boolean;

package/src/daemon/message-types/sessions.ts

@@ -24,6 +24,8 @@ export interface SessionTransportMetadata {
   hints?: string[];
   /** Optional concise UX brief for this channel. */
   uxBrief?: string;
+  /** Chat type from the gateway (e.g. "private", "group", "supergroup", "channel"). */
+  chatType?: string;
 }
 
 export interface SessionCreateRequest {

package/src/daemon/parse-actual-tokens-from-error.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test";
+
+import { parseActualTokensFromError } from "./session-agent-loop.js";
+
+describe("parseActualTokensFromError", () => {
+  test("returns null for null input", () => {
+    expect(parseActualTokensFromError(null)).toBeNull();
+  });
+
+  test("returns null for empty string", () => {
+    expect(parseActualTokensFromError("")).toBeNull();
+  });
+
+  test("returns null for unrelated error message", () => {
+    expect(
+      parseActualTokensFromError("something went wrong"),
+    ).toBeNull();
+  });
+
+  test("parses Anthropic-style error: prompt is too long: N tokens > M maximum", () => {
+    expect(
+      parseActualTokensFromError(
+        "prompt is too long: 242201 tokens > 200000 maximum",
+      ),
+    ).toBe(242201);
+  });
+
+  test("parses wrapped ProviderError from Anthropic", () => {
+    expect(
+      parseActualTokensFromError(
+        "Anthropic API error (400): prompt is too long: 242201 tokens > 200000 maximum",
+      ),
+    ).toBe(242201);
+  });
+
+  test("parses OpenAI-style error: too many input tokens: N > M", () => {
+    expect(
+      parseActualTokensFromError("too many input tokens: 150000 > 128000"),
+    ).toBe(150000);
+  });
+
+  test("handles comma-separated numbers", () => {
+    expect(
+      parseActualTokensFromError(
+        "prompt is too long: 242,201 tokens > 200,000 maximum",
+      ),
+    ).toBe(242201);
+  });
+
+  test("handles comma-separated numbers in fallback path", () => {
+    expect(
+      parseActualTokensFromError("too many input tokens: 150,000 > 128,000"),
+    ).toBe(150000);
+  });
+
+  test("parses singular 'token' (without s)", () => {
+    expect(
+      parseActualTokensFromError("prompt is too long: 1 token > 0 maximum"),
+    ).toBe(1);
+  });
+
+  test("handles >= comparator", () => {
+    expect(
+      parseActualTokensFromError(
+        "prompt is too long: 242201 tokens ≥ 200000 maximum",
+      ),
+    ).toBe(242201);
+  });
+
+  test("returns null when no numeric pattern matches", () => {
+    expect(
+      parseActualTokensFromError("context window exceeded"),
+    ).toBeNull();
+  });
+});

package/src/daemon/server.ts

@@ -538,6 +538,22 @@ export class DaemonServer {
         );
         newSession.updateClient(sendToClient, true);
         await newSession.loadFromDb();
+        // Restore trust/auth context and assistant ID from stored options so
+        // that evicted sessions rehydrated by undo/regenerate don't run with
+        // unscoped history.  Without this, an untrusted actor could operate
+        // on the full conversation after eviction.
+        if (storedOptions?.assistantId) {
+          newSession.setAssistantId(storedOptions.assistantId);
+        }
+        if (storedOptions?.trustContext) {
+          newSession.setTrustContext(storedOptions.trustContext);
+        }
+        if (storedOptions?.authContext) {
+          newSession.setAuthContext(storedOptions.authContext);
+        }
+        if (storedOptions?.trustContext || storedOptions?.authContext) {
+          await newSession.ensureActorScopedHistory();
+        }
         this.applyTransportMetadata(newSession, storedOptions);
         this.sessions.set(conversationId, newSession);
         return newSession;
@@ -639,7 +655,12 @@ export class DaemonServer {
     session.setAuthContext(options?.authContext ?? null);
     await session.ensureActorScopedHistory();
     session.setChannelCapabilities(
-      resolveChannelCapabilities(sourceChannel, sourceInterface),
+      resolveChannelCapabilities(
+        sourceChannel,
+        sourceInterface,
+        null,
+        options?.transport?.chatType,
+      ),
     );
     // Only create the host bash proxy for desktop client interfaces that can
     // execute commands on the user's machine. Non-desktop sessions (CLI,
@@ -778,7 +799,7 @@ export class DaemonServer {
       sourceInterface,
     );
 
-    const slashResult = resolveSlash(content);
+    const slashResult = await resolveSlash(content);
 
     if (slashResult.kind === "unknown") {
       const serverTurnCtx = session.getTurnChannelContext();

package/src/daemon/session-agent-loop-handlers.ts

@@ -865,7 +865,7 @@ export async function dispatchAgentEvent(
         type: "tool_result",
         toolName: "",
         result: "",
-        isError: false,
+        isError: event.isError,
         sessionId: deps.ctx.conversationId,
         toolUseId: event.toolUseId,
       });

package/src/daemon/session-agent-loop.ts

@@ -133,7 +133,7 @@ const log = getLogger("session-agent-loop");
  *
  * Returns the actual token count or null if it cannot be parsed.
  */
-function parseActualTokensFromError(
+export function parseActualTokensFromError(
   errorMessage: string | null,
 ): number | null {
   if (!errorMessage) return null;
@@ -710,10 +710,11 @@ export async function runAgentLoopImpl(
     const preflightBudget = Math.floor(providerMaxTokens * (1 - safetyMargin));
     let reducerState: ReducerState | undefined;
 
+    const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
     const preflightTokens = estimatePromptTokens(
       runMessages,
       ctx.systemPrompt,
-      { providerName: ctx.provider.name },
+      { providerName: ctx.provider.name, toolTokenBudget },
     );
 
     if (overflowRecovery.enabled && preflightTokens > preflightBudget) {
@@ -747,6 +748,7 @@ export async function runAgentLoopImpl(
             systemPrompt: ctx.systemPrompt,
             contextWindow: config.contextWindow,
             targetTokens: preflightBudget,
+            toolTokenBudget,
           },
           reducerState,
           (msgs, signal, opts) =>
@@ -863,7 +865,7 @@ export async function runAgentLoopImpl(
         const estimated = estimatePromptTokens(
           checkpoint.history,
           ctx.systemPrompt,
-          { providerName: ctx.provider.name },
+          { providerName: ctx.provider.name, toolTokenBudget },
         );
         if (estimated > midLoopThreshold) {
           rlog.warn(
@@ -993,6 +995,23 @@ export async function runAgentLoopImpl(
       );
     }
 
+    // If mid-loop compaction exhausted all attempts but the agent loop
+    // still yielded (yieldedForBudget is true), the turn is incomplete.
+    // Escalate to the convergence loop's more aggressive reducer tiers
+    // (tool-result truncation, media stubbing, injection downgrade)
+    // instead of silently treating an incomplete turn as done.
+    if (yieldedForBudget && !abortController.signal.aborted) {
+      rlog.warn(
+        {
+          phase: "mid-loop-compact",
+          midLoopCompactAttempts,
+          maxAttempts: overflowRecovery.maxAttempts,
+        },
+        "Mid-loop compaction exhausted all attempts — escalating to convergence loop",
+      );
+      state.contextTooLargeDetected = true;
+    }
+
     // One-shot ordering error retry
     if (
       state.orderingErrorDetected &&
@@ -1045,6 +1064,7 @@ export async function runAgentLoopImpl(
             ),
         });
         preRepairMessages = updatedHistory;
+        preRunHistoryLength = updatedHistory.length;
       }
       if (!reducerState) {
         reducerState = createInitialReducerState();
@@ -1061,7 +1081,7 @@ export async function runAgentLoopImpl(
       const estimatedTokensAtOverflow = estimatePromptTokens(
         ctx.messages,
         ctx.systemPrompt,
-        { providerName: ctx.provider.name },
+        { providerName: ctx.provider.name, toolTokenBudget },
       );
       let correctedTarget = preflightBudget;
       if (actualTokens && estimatedTokensAtOverflow > 0) {
@@ -1113,6 +1133,7 @@ export async function runAgentLoopImpl(
             systemPrompt: ctx.systemPrompt,
             contextWindow: config.contextWindow,
             targetTokens: correctedTarget,
+            toolTokenBudget,
           },
           reducerState,
           (msgs, signal, opts) =>
@@ -1124,12 +1145,6 @@ export async function runAgentLoopImpl(
         ctx.messages = step.messages;
         currentInjectionMode = step.state.injectionMode;
 
-        // If the reducer is now exhausted without compacting, break out
-        // so the overflow policy path can attempt emergency compaction.
-        if (reducerState.exhausted && !step.compactionResult?.compacted) {
-          break;
-        }
-
         if (step.compactionResult?.compacted) {
           ctx.contextCompactedMessageCount +=
             step.compactionResult.compactedPersistedMessages;
@@ -1183,77 +1198,10 @@ export async function runAgentLoopImpl(
         );
       }
 
-      // When all reducer tiers are exhausted but the context is still too
-      // large, attempt one last emergency compaction before consulting the
-      // overflow policy. This covers the case where progress was made
-      // (messages grew) and the normal tiers couldn't compact enough.
-      if (state.contextTooLargeDetected && reducerState.exhausted) {
-        const emergencyCompact = await ctx.contextWindowManager.maybeCompact(
-          ctx.messages,
-          abortController.signal,
-          {
-            lastCompactedAt: ctx.contextCompactedAt ?? undefined,
-            force: true,
-            minKeepRecentUserTurns: 0,
-            targetInputTokensOverride: correctedTarget,
-          },
-        );
-        if (emergencyCompact.compacted) {
-          ctx.messages = emergencyCompact.messages;
-          ctx.contextCompactedMessageCount +=
-            emergencyCompact.compactedPersistedMessages;
-          ctx.contextCompactedAt = Date.now();
-          updateConversationContextWindow(
-            ctx.conversationId,
-            emergencyCompact.summaryText,
-            ctx.contextCompactedMessageCount,
-          );
-          onEvent({
-            type: "context_compacted",
-            previousEstimatedInputTokens:
-              emergencyCompact.previousEstimatedInputTokens,
-            estimatedInputTokens: emergencyCompact.estimatedInputTokens,
-            maxInputTokens: emergencyCompact.maxInputTokens,
-            thresholdTokens: emergencyCompact.thresholdTokens,
-            compactedMessages: emergencyCompact.compactedMessages,
-            summaryCalls: emergencyCompact.summaryCalls,
-            summaryInputTokens: emergencyCompact.summaryInputTokens,
-            summaryOutputTokens: emergencyCompact.summaryOutputTokens,
-            summaryModel: emergencyCompact.summaryModel,
-          });
-          emitUsage(
-            ctx,
-            emergencyCompact.summaryInputTokens,
-            emergencyCompact.summaryOutputTokens,
-            emergencyCompact.summaryModel,
-            onEvent,
-            "context_compactor",
-            reqId,
-            emergencyCompact.summaryCacheCreationInputTokens ?? 0,
-            emergencyCompact.summaryCacheReadInputTokens ?? 0,
-            collapseRawResponses(emergencyCompact.summaryRawResponses),
-          );
-
-          runMessages = applyRuntimeInjections(ctx.messages, {
-            ...injectionOpts,
-            mode: currentInjectionMode,
-          });
-          preRepairMessages = runMessages;
-          preRunHistoryLength = runMessages.length;
-          state.contextTooLargeDetected = false;
-
-          updatedHistory = await ctx.agentLoop.run(
-            runMessages,
-            eventHandler,
-            abortController.signal,
-            reqId,
-            onCheckpoint,
-          );
-        }
-      }
-
       // All reducer tiers exhausted but provider still rejects —
       // consult the overflow policy for latest-turn compression.
+      // Emergency compaction is deferred to the policy-gated paths below
+      // so that `request_user_approval` sessions collect consent first.
       if (state.contextTooLargeDetected) {
         const action = resolveOverflowAction({
           overflowRecovery,

package/src/daemon/session-error.ts

@@ -218,7 +218,7 @@ function classifyCore(
         return {
           code: "PROVIDER_WEB_SEARCH",
           userMessage:
-            "An internal error occurred with web search. Retrying...",
+            "An internal error occurred with web search. Please try again.",
           retryable: true,
           errorCategory: "web_search_ordering",
         };
@@ -226,7 +226,7 @@ function classifyCore(
       if (isOrderingError(message)) {
         return {
           code: "PROVIDER_ORDERING",
-          userMessage: "An internal error occurred. Retrying...",
+          userMessage: "An internal error occurred. Please try again.",
           retryable: true,
           errorCategory: "tool_ordering",
         };
@@ -308,7 +308,8 @@ function classifyByMessage(
   if (isWebSearchOrderingError(message)) {
     return {
       code: "PROVIDER_WEB_SEARCH",
-      userMessage: "An internal error occurred with web search. Retrying...",
+      userMessage:
+        "An internal error occurred with web search. Please try again.",
       retryable: true,
       errorCategory: "web_search_ordering",
     };
@@ -318,7 +319,7 @@ function classifyByMessage(
   if (isOrderingError(message)) {
     return {
       code: "PROVIDER_ORDERING",
-      userMessage: "An internal error occurred. Retrying...",
+      userMessage: "An internal error occurred. Please try again.",
       retryable: true,
       errorCategory: "tool_ordering",
     };