@vellumai/assistant 0.7.1 → 0.7.2

package/src/schedule/scheduler.ts

@@ -1,4 +1,3 @@
-import type { LLMCallSite } from "../config/schemas/llm.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getConversation } from "../memory/conversation-crud.js";
@@ -12,40 +11,26 @@ import {
   type WatcherNotifier,
 } from "../watcher/engine.js";
 import { hasSetConstructs } from "./recurrence-engine.js";
+import { applyRetryDecision, decideRetry } from "./retry-policy.js";
 import { runScript, type ScriptResult } from "./run-script.js";
 import {
   claimDueSchedules,
   completeOneShot,
   completeScheduleRun,
   createScheduleRun,
-  failOneShot,
   failOneShotPermanently,
   getLastScheduleConversationId,
+  resetRetryCount,
   retryOneShot,
   type RoutingIntent,
+  type ScheduleJob,
+  scheduleRetry,
 } from "./schedule-store.js";
 
 const log = getLogger("scheduler");
 
-export interface ScheduleMessageOptions {
-  trustClass?: "guardian" | "trusted_contact" | "unknown";
-  taskRunId?: string;
-  /**
-   * Optional LLM call-site identifier propagated to the per-call provider
-   * config. Schedule and sequence callers will start passing their own call-site
-   * (e.g. for a future scheduled-agent profile) once PRs 7-11 migrate them off
-   * the default `mainAgent` route.
-   */
-  callSite?: LLMCallSite;
-}
-
-export type ScheduleMessageProcessor = (
-  conversationId: string,
-  message: string,
-  options?: ScheduleMessageOptions,
-) => Promise<unknown>;
-
-export type ScheduleNotifyModeNotifier = (payload: {
+import type { ScheduleMessageProcessor } from "./scheduler-types.js";
+type ScheduleNotifyModeNotifier = (payload: {
   id: string;
   label: string;
   message: string;
@@ -53,7 +38,7 @@ export type ScheduleNotifyModeNotifier = (payload: {
   routingHints: Record<string, unknown>;
 }) => void | Promise<void>;
 
-export type ScheduleConversationCreatedNotifier = (info: {
+type ScheduleConversationCreatedNotifier = (info: {
   conversationId: string;
   scheduleJobId: string;
   title: string;
@@ -73,6 +58,26 @@ const TICK_INTERVAL_MS = 15_000;
  */
 const WAKE_MAX_RETRIES = 20;
 
+function handleExecutionFailure(params: {
+  job: ScheduleJob;
+  errorMsg: string;
+  isOneShot: boolean;
+}): void {
+  const decision = decideRetry(params.job);
+  applyRetryDecision({
+    job: params.job,
+    isOneShot: params.isOneShot,
+    errorMsg: params.errorMsg,
+    decision,
+    scheduleRetry,
+    failOneShotPermanently,
+    resetRetryCount,
+    emitAlert: (title, summary, dedupKey) =>
+      emitScheduleFeedEvent({ title, summary, dedupKey }),
+    log,
+  });
+}
+
 export function startScheduler(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
@@ -154,6 +159,8 @@ async function runScheduleOnce(
           routingHints: job.routingHints,
         });
         if (isOneShot) {
+          const successRunId = createScheduleRun(job.id, `notify-ok:${job.id}`);
+          completeScheduleRun(successRunId, { status: "ok" });
           completeOneShot(job.id);
           emitScheduleFeedEvent({
             title: job.name,
@@ -176,15 +183,10 @@ async function runScheduleOnce(
           { err, jobId: job.id, name: job.name, isOneShot },
           "Schedule notification failed",
         );
-        if (isOneShot) {
-          failOneShot(job.id);
-        } else {
-          // Track recurring notify-mode failures via a schedule run so the
-          // occurrence isn't silently lost and lastStatus/retryCount update.
-          const errorMsg = err instanceof Error ? err.message : String(err);
-          const runId = createScheduleRun(job.id, `notify-error:${job.id}`);
-          completeScheduleRun(runId, { status: "error", error: errorMsg });
-        }
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const errorRunId = createScheduleRun(job.id, `notify-error:${job.id}`);
+        completeScheduleRun(errorRunId, { status: "error", error: errorMsg });
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -222,7 +224,9 @@ async function runScheduleOnce(
           }
           if (isOneShot) completeOneShot(job.id);
         } else {
-          if (isOneShot) failOneShot(job.id);
+          const errorMsg =
+            result.stderr || "Script exited with non-zero status";
+          handleExecutionFailure({ job, errorMsg, isOneShot });
         }
       } catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
@@ -231,7 +235,7 @@ async function runScheduleOnce(
           "Script schedule execution failed",
         );
         completeScheduleRun(runId, { status: "error", error: errorMsg });
-        if (isOneShot) failOneShot(job.id);
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -309,7 +313,11 @@ async function runScheduleOnce(
           continue;
         }
 
-        if (isOneShot) completeOneShot(job.id);
+        if (isOneShot) {
+          const successRunId = createScheduleRun(job.id, `wake-ok:${job.id}`);
+          completeScheduleRun(successRunId, { status: "ok" });
+          completeOneShot(job.id);
+        }
         if (!job.quiet) {
           emitScheduleFeedEvent({
             title: job.name,
@@ -322,7 +330,16 @@ async function runScheduleOnce(
           { err, jobId: job.id, name: job.name, wakeConversationId, isOneShot },
           "Wake schedule execution failed",
         );
-        if (isOneShot) failOneShot(job.id);
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        const wakeErrorRunId = createScheduleRun(
+          job.id,
+          `wake-error:${job.id}`,
+        );
+        completeScheduleRun(wakeErrorRunId, {
+          status: "error",
+          error: errorMsg,
+        });
+        handleExecutionFailure({ job, errorMsg, isOneShot });
       }
       processed += 1;
       continue;
@@ -380,7 +397,11 @@ async function runScheduleOnce(
             status: "error",
             error: result.error ?? "Task run failed",
           });
-          if (isOneShot) failOneShot(job.id);
+          handleExecutionFailure({
+            job,
+            errorMsg: result.error ?? "Task run failed",
+            isOneShot,
+          });
         } else {
           completeScheduleRun(runId, { status: "ok" });
           if (!job.quiet) {
@@ -424,7 +445,11 @@ async function runScheduleOnce(
         });
         const runId = createScheduleRun(job.id, fallbackConversation.id);
         completeScheduleRun(runId, { status: "error", error: message });
-        if (isOneShot) failOneShot(job.id);
+        handleExecutionFailure({
+          job,
+          errorMsg: message,
+          isOneShot,
+        });
       }
       continue;
     }
@@ -507,7 +532,7 @@ async function runScheduleOnce(
           : "Schedule execution failed",
       );
       completeScheduleRun(runId, { status: "error", error: message });
-      if (isOneShot) failOneShot(job.id);
+      handleExecutionFailure({ job, errorMsg: message, isOneShot });
 
       // Only skip invalidation when the conversation was *actually* reused,
       // i.e. it contains prior successful context worth preserving. When

package/src/security/oauth-callback-registry.ts

@@ -4,6 +4,14 @@
  * back to the runtime code that initiated the OAuth handshake.
  */
 
+/**
+ * Sibling: `assistant/src/mcp/mcp-auth-state.ts`. The MCP auth state map sits
+ * one layer up from this registry — it tracks polling-visible status per
+ * MCP server, while this registry resolves the OAuth code-arrival promise
+ * keyed by OAuth `state`. The callback registry is shared by all
+ * gateway-transport OAuth flows (MCP and otherwise); the MCP state map is
+ * MCP-specific.
+ */
 interface PendingCallback {
   resolve: (code: string) => void;
   reject: (error: Error) => void;

package/src/sequence/analytics.ts

@@ -15,7 +15,7 @@ import type { Sequence } from "./types.js";
 
 // ── Event tracking ──────────────────────────────────────────────────
 
-export type SequenceEventType =
+type SequenceEventType =
   | "send"
   | "reply"
   | "complete"
@@ -24,7 +24,7 @@ export type SequenceEventType =
   | "pause"
   | "resume";
 
-export interface SequenceEvent {
+interface SequenceEvent {
   id: string;
   sequenceId: string;
   enrollmentId: string;
@@ -74,7 +74,7 @@ function getRecentEvents(limit = 20): SequenceEvent[] {
 
 // ── Metrics ─────────────────────────────────────────────────────────
 
-export interface SequenceMetrics {
+interface SequenceMetrics {
   sequenceId: string;
   sequenceName: string;
   status: string;
@@ -90,7 +90,7 @@ export interface SequenceMetrics {
   avgTimeToReplyMs: number | null;
 }
 
-export interface StepMetrics {
+interface StepMetrics {
   stepIndex: number;
   subject: string;
   sends: number;
@@ -98,7 +98,7 @@ export interface StepMetrics {
   dropOff: number;
 }
 
-export interface DashboardData {
+interface DashboardData {
   summary: {
     totalSequences: number;
     activeSequences: number;

package/src/sequence/engine.ts

@@ -9,7 +9,7 @@
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getMessages } from "../memory/conversation-crud.js";
-import type { ScheduleMessageProcessor } from "../schedule/scheduler.js";
+import type { ScheduleMessageProcessor } from "../schedule/scheduler-types.js";
 import { getLogger } from "../util/logger.js";
 import { recordEvent } from "./analytics.js";
 import { checkAllPreSend, recordSend } from "./guardrails.js";

package/src/skills/catalog-files.ts

@@ -64,14 +64,8 @@ function classifyByName(name: string): boolean {
  * depends on `catalog-cache.ts`, which would otherwise be reachable via
  * the handler module.
  */
-export interface SkillFileEntry {
-  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
-  name: string; // basename
-  size: number;
-  mimeType: string;
-  isBinary: boolean;
-  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
-}
+import type { SkillFileEntry } from "./skill-file-types.js";
+export type { SkillFileEntry } from "./skill-file-types.js";
 
 // ─── Platform response contracts ─────────────────────────────────────────────
 //

package/src/skills/include-graph.ts

@@ -1,6 +1,6 @@
 import type { SkillSummary } from "../config/skills.js";
 
-export interface IncludeGraphResult {
+interface IncludeGraphResult {
   /** Ordered list of all skill IDs visited during traversal (including the root). */
   visited: string[];
 }
@@ -37,12 +37,12 @@ export function getImmediateChildren(
   return children;
 }
 
-export interface IncludeValidationSuccess {
+interface IncludeValidationSuccess {
   ok: true;
   visited: string[];
 }
 
-export interface IncludeValidationError {
+interface IncludeValidationError {
   ok: false;
   error: "missing";
   missingChildId: string;
@@ -50,13 +50,13 @@ export interface IncludeValidationError {
   path: string[]; // full path from root to the parent that referenced the missing child
 }
 
-export interface IncludeValidationCycleError {
+interface IncludeValidationCycleError {
   ok: false;
   error: "cycle";
   cyclePath: string[]; // the IDs forming the cycle, e.g. ['a', 'b', 'c', 'a']
 }
 
-export type IncludeValidationResult =
+type IncludeValidationResult =
   | IncludeValidationSuccess
   | IncludeValidationError
   | IncludeValidationCycleError;

package/src/skills/remote-skill-policy.ts

@@ -1,4 +1,4 @@
-export type RemoteSkillProvider = "clawhub" | "skillssh";
+type RemoteSkillProvider = "clawhub" | "skillssh";
 
 export type SkillsShRisk =
   | "safe"
@@ -26,12 +26,12 @@ export interface RemoteSkillPolicy {
   maxSkillsShRisk: SkillsShRiskThreshold;
 }
 
-export interface ClawhubModerationState {
+interface ClawhubModerationState {
   isSuspicious?: boolean;
   isMalwareBlocked?: boolean;
 }
 
-export interface SkillsShAuditState {
+interface SkillsShAuditState {
   risk?: SkillsShRisk | null;
 }
 
@@ -40,12 +40,12 @@ interface RemoteSkillCandidateBase {
   slug: string;
 }
 
-export interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "clawhub";
   moderation?: ClawhubModerationState | null;
 }
 
-export interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "skillssh";
   audit?: SkillsShAuditState | null;
 }

package/src/skills/skill-file-provider.ts

@@ -1,5 +1,5 @@
 import type { SlimSkillResponse } from "../daemon/message-types/skills.js";
-import type { SkillFileEntry } from "./catalog-files.js";
+import type { SkillFileEntry } from "./skill-file-types.js";
 
 /**
  * A file provider can resolve file listings and single-file content for

package/src/skills/skill-file-types.ts

@@ -0,0 +1,13 @@
+/**
+ * Types extracted from catalog-files.ts to break the
+ * catalog-files ↔ skill-file-provider cycle.
+ */
+
+export interface SkillFileEntry {
+  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
+  name: string; // basename
+  size: number;
+  mimeType: string;
+  isBinary: boolean;
+  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
+}

package/src/skills/skillssh-audit-types.ts

@@ -0,0 +1,28 @@
+/**
+ * Audit types for SkillSSH partner security analysis.
+ *
+ * Extracted as a leaf module so daemon message types can reference
+ * PartnerAudit without pulling in the full skillssh-registry module
+ * (which transitively imports cli/program and the entire CLI graph).
+ */
+
+export type RiskLevel =
+  | "safe"
+  | "low"
+  | "medium"
+  | "high"
+  | "critical"
+  | "unknown";
+
+export interface PartnerAudit {
+  risk: RiskLevel;
+  alerts?: number;
+  score?: number;
+  analyzedAt: string;
+}
+
+/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
+export type SkillAuditData = Record<string, PartnerAudit>;
+
+/** Map from skill slug to per-provider audit data */
+export type AuditResponse = Record<string, SkillAuditData>;

package/src/skills/skillssh-registry.ts

@@ -6,6 +6,14 @@ import { dirname, join, resolve, sep } from "node:path";
 import { getWorkspaceSkillsDir } from "../util/platform.js";
 import { upsertSkillsIndex } from "./catalog-install.js";
 import { computeSkillHash, writeInstallMeta } from "./install-meta.js";
+import type {
+  AuditResponse,
+  PartnerAudit,
+  RiskLevel,
+  SkillAuditData,
+} from "./skillssh-audit-types.js";
+
+export type { AuditResponse, PartnerAudit, RiskLevel, SkillAuditData };
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -17,27 +25,6 @@ export interface SkillsShSearchResult {
   source: string; // e.g. "vercel-labs/agent-skills"
 }
 
-export type RiskLevel =
-  | "safe"
-  | "low"
-  | "medium"
-  | "high"
-  | "critical"
-  | "unknown";
-
-export interface PartnerAudit {
-  risk: RiskLevel;
-  alerts?: number;
-  score?: number;
-  analyzedAt: string;
-}
-
-/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
-export type SkillAuditData = Record<string, PartnerAudit>;
-
-/** Map from skill slug to per-provider audit data */
-export type AuditResponse = Record<string, SkillAuditData>;
-
 export interface ResolvedSkillSource {
   owner: string;
   repo: string;

package/src/telemetry/types.ts

@@ -21,6 +21,8 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
   llm_call_site: LLMCallSite | null;
   inference_profile: string | null;
   inference_profile_source: UsageAttributionProfileSource | null;
+  /** Computed estimated cost in USD for this LLM call. Null when pricing data is unavailable. */
+  cost: number | null;
 }
 
 /** Turn event — one per user message. */

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -389,6 +389,7 @@ describe("UsageTelemetryReporter", () => {
     expect(e.llm_call_site).toBe("compactionAgent");
     expect(e.inference_profile).toBe("quality-optimized");
     expect(e.inference_profile_source).toBe("conversation");
+    expect(e.cost).toBe(0.001);
     expect(e.recorded_at).toBe(1700000099000);
   });
 
@@ -419,6 +420,26 @@ describe("UsageTelemetryReporter", () => {
     });
   });
 
+  test("cost is null when estimatedCostUsd is null (unpriced event)", async () => {
+    const event = makeUsageEvent({
+      id: "evt-unpriced",
+      estimatedCostUsd: null,
+      pricingStatus: "unpriced",
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events[0].cost).toBeNull();
+  });
+
   test("organization_id and user_id included in payload when available", async () => {
     mockGetPlatformOrganizationId.mockReturnValue("org-123");
     mockGetPlatformUserId.mockReturnValue("user-456");

package/src/telemetry/usage-telemetry-reporter.ts

@@ -194,6 +194,7 @@ export class UsageTelemetryReporter {
             llm_call_site: e.callSite,
             inference_profile: e.inferenceProfile,
             inference_profile_source: e.inferenceProfileSource,
+            cost: e.estimatedCostUsd ?? null,
             recorded_at: e.createdAt,
           }),
         ),

package/src/tools/app-control/skill-proxy-bridge.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared helper for app-control skill wrapper scripts.
+ *
+ * Each wrapper calls forwardAppControlProxyTool() to delegate execution to
+ * the proxy resolver, which forwards the call to the connected client.
+ */
+
+import type { ToolContext, ToolExecutionResult } from "../types.js";
+
+/**
+ * Forward an app-control proxy tool call through the context's proxyToolResolver.
+ *
+ * Returns a clear error result if the resolver is missing (e.g. when the tool
+ * is invoked outside a session with a connected client).
+ */
+export function forwardAppControlProxyTool(
+  toolName: string,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  if (!context.proxyToolResolver) {
+    return Promise.resolve({
+      content: `Cannot execute ${toolName}: no proxy resolver available. This tool requires a connected client.`,
+      isError: true,
+    });
+  }
+  return context.proxyToolResolver(toolName, input);
+}