@vellumai/assistant 0.7.1 → 0.7.3

package/src/runtime/routes/oauth-connect-routes.ts

@@ -0,0 +1,153 @@
+/**
+ * Internal routes for daemon-owned OAuth connect flows (CLI gateway transport fix).
+ *
+ * POST internal/oauth/connect/start   — starts the flow in the daemon, returns auth URL
+ * GET  internal/oauth/connect/status/:state — polls current flow status
+ */
+
+import { z } from "zod";
+
+import { orchestrateOAuthConnect } from "../../oauth/connect-orchestrator.js";
+import {
+  getOAuthConnectState,
+  setOAuthConnectComplete,
+  setOAuthConnectError,
+  setOAuthConnectPending,
+} from "../../oauth/oauth-connect-state.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
+
+const log = getLogger("oauth-connect-routes");
+
+async function handleOAuthConnectStart({
+  body,
+}: {
+  body?: Record<string, unknown>;
+}): Promise<{ auth_url: string; state: string }> {
+  const {
+    service,
+    clientId,
+    clientSecret,
+    callbackTransport,
+    requestedScopes,
+  } = (body ?? {}) as {
+    service: string;
+    clientId: string;
+    clientSecret?: string;
+    callbackTransport?: string;
+    requestedScopes?: string[];
+  };
+
+  if (!service) throw new BadRequestError("service is required");
+  if (!clientId) throw new BadRequestError("clientId is required");
+  if (callbackTransport !== "loopback" && callbackTransport !== "gateway") {
+    throw new BadRequestError(
+      'callbackTransport must be "loopback" or "gateway"',
+    );
+  }
+
+  // Capture resolvedState separately so the onDeferredComplete closure can
+  // reference it without a reference-before-assignment risk (the fire-and-forget
+  // tail only fires after the await resolves, by which point resolvedState is set).
+  // eslint-disable-next-line prefer-const -- intentional forward-declared binding
+  let resolvedState: string | undefined;
+
+  let result: Awaited<ReturnType<typeof orchestrateOAuthConnect>>;
+  try {
+    result = await orchestrateOAuthConnect({
+      service,
+      clientId,
+      clientSecret,
+      callbackTransport,
+      ...(requestedScopes ? { requestedScopes } : {}),
+      isInteractive: false,
+      onDeferredComplete: (r) => {
+        if (!resolvedState) return;
+        if (r.success) {
+          setOAuthConnectComplete(resolvedState, r.service, r.accountInfo, r.grantedScopes);
+        } else {
+          setOAuthConnectError(resolvedState, r.service, r.error ?? "OAuth connect failed");
+        }
+      },
+    });
+  } catch (err) {
+    throw new InternalError(err instanceof Error ? err.message : String(err));
+  }
+
+  if (!result.success) {
+    throw new InternalError(result.error);
+  }
+  if (!result.deferred) {
+    throw new InternalError("Orchestrator returned non-deferred result");
+  }
+
+  resolvedState = result.state;
+  setOAuthConnectPending(result.state, service);
+  log.info({ state: result.state, service }, "oauth connect flow started");
+  return { auth_url: result.authorizeUrl, state: result.state };
+}
+
+function handleOAuthConnectStatus({
+  pathParams,
+}: {
+  pathParams?: Record<string, string>;
+}): {
+  status: "pending" | "complete" | "error";
+  service: string;
+  account_info?: string;
+  granted_scopes?: string[];
+  error?: string;
+} {
+  const { state } = pathParams as { state: string };
+  const flowState = getOAuthConnectState(state);
+
+  if (flowState === null) {
+    throw new NotFoundError(`No active OAuth connect flow for state "${state}"`);
+  }
+
+  if (flowState.status === "pending") return { status: "pending", service: flowState.service };
+  if (flowState.status === "complete") {
+    return {
+      status: "complete",
+      service: flowState.service,
+      ...(flowState.accountInfo ? { account_info: flowState.accountInfo } : {}),
+      ...(flowState.grantedScopes ? { granted_scopes: flowState.grantedScopes } : {}),
+    };
+  }
+  return { status: "error", service: flowState.service, error: flowState.error };
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "internal_oauth_connect_start",
+    endpoint: "internal/oauth/connect/start",
+    method: "POST",
+    summary: "Start daemon-owned OAuth connect flow",
+    description:
+      "Starts an OAuth connect flow in the daemon and returns the authorization URL for the CLI to open in the browser.",
+    tags: ["internal"],
+    requestBody: z.object({
+      service: z.string(),
+      clientId: z.string(),
+      clientSecret: z.string().optional(),
+      callbackTransport: z.enum(["loopback", "gateway"]),
+      requestedScopes: z.array(z.string()).optional(),
+    }),
+    handler: handleOAuthConnectStart,
+  },
+  {
+    operationId: "internal_oauth_connect_status",
+    endpoint: "internal/oauth/connect/status/:state",
+    method: "GET",
+    summary: "Poll daemon OAuth connect flow status",
+    description:
+      "Returns the current status of an in-flight daemon-owned OAuth connect flow (pending/complete/error).",
+    tags: ["internal"],
+    pathParams: [{ name: "state" }],
+    additionalResponses: {
+      "404": { description: "No active OAuth connect flow for the given state token" },
+    },
+    handler: handleOAuthConnectStatus,
+  },
+];

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

@@ -54,6 +54,9 @@ function handleListSchedules(queryParams: Record<string, string>) {
       nextRunAt: j.nextRunAt,
       lastRunAt: j.lastRunAt,
       lastStatus: j.lastStatus,
+      retryCount: j.retryCount,
+      maxRetries: j.maxRetries,
+      retryBackoffMs: j.retryBackoffMs,
       description:
         j.syntax === "cron"
           ? describeCronExpression(j.cronExpression)
@@ -139,6 +142,8 @@ function handleUpdateSchedule(id: string, body: Record<string, unknown>) {
     "quiet",
     "reuseConversation",
     "wakeConversationId",
+    "maxRetries",
+    "retryBackoffMs",
   ] as const) {
     if (key in body) {
       updates[key] = body[key];
@@ -294,6 +299,8 @@ export const ROUTES: RouteDefinition[] = [
         .describe("single_channel, multi_channel, or all_channels"),
       quiet: z.boolean(),
       reuseConversation: z.boolean(),
+      maxRetries: z.number().describe("Maximum retry attempts"),
+      retryBackoffMs: z.number().describe("Retry backoff in milliseconds"),
     }),
     responseBody: z.object({
       schedules: z.array(z.unknown()).describe("Updated schedule list"),

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

@@ -79,7 +79,7 @@ export function normalizeTelegramDestination(destination: string): string {
 // Input / output types
 // ---------------------------------------------------------------------------
 
-export interface StartOutboundParams {
+interface StartOutboundParams {
   channel: ChannelId;
   destination?: string;
   rebind?: boolean;
@@ -87,13 +87,13 @@ export interface StartOutboundParams {
   originConversationId?: string;
 }
 
-export interface ResendOutboundParams {
+interface ResendOutboundParams {
   channel: ChannelId;
   /** Origin conversation ID so completion/failure pointers can route back on resend. */
   originConversationId?: string;
 }
 
-export interface CancelOutboundParams {
+interface CancelOutboundParams {
   channel: ChannelId;
 }
 
@@ -102,7 +102,7 @@ export interface CancelOutboundParams {
  * Maps 1:1 with the fields in ChannelVerificationSessionResponse minus the
  * `type` discriminant.
  */
-export interface OutboundActionResult {
+interface OutboundActionResult {
   success: boolean;
   error?: string;
   message?: string;

package/src/runtime/verification-templates.ts

@@ -42,9 +42,6 @@ export const GUARDIAN_VERIFY_TEMPLATE_KEYS = {
   CHANNEL_BOOTSTRAP_BOUND: "guardian_verify.channel.bootstrap_bound",
 } as const;
 
-export type GuardianVerifyTemplateKey =
-  (typeof GUARDIAN_VERIFY_TEMPLATE_KEYS)[keyof typeof GUARDIAN_VERIFY_TEMPLATE_KEYS];
-
 /** Template keys for Telegram/Slack text-based verification messages. */
 type TextVerifyTemplateKey =
   | typeof GUARDIAN_VERIFY_TEMPLATE_KEYS.ALREADY_VERIFIED
@@ -56,7 +53,7 @@ type TextVerifyTemplateKey =
   | typeof GUARDIAN_VERIFY_TEMPLATE_KEYS.SLACK_TRUSTED_CONTACT_RESEND;
 
 /** Template keys for deterministic channel verification reply messages. */
-export type ChannelVerifyReplyTemplateKey =
+type ChannelVerifyReplyTemplateKey =
   | typeof GUARDIAN_VERIFY_TEMPLATE_KEYS.CHANNEL_VERIFY_SUCCESS
   | typeof GUARDIAN_VERIFY_TEMPLATE_KEYS.CHANNEL_VERIFY_FAILED
   | typeof GUARDIAN_VERIFY_TEMPLATE_KEYS.CHANNEL_BOOTSTRAP_BOUND;
@@ -65,18 +62,18 @@ export type ChannelVerifyReplyTemplateKey =
 // Template Variables
 // ---------------------------------------------------------------------------
 
-export interface GuardianVerifyTemplateVars {
+interface GuardianVerifyTemplateVars {
   code: string;
   expiresInMinutes: number;
   assistantName?: string;
 }
 
-export interface GuardianVerifyVoiceTemplateVars {
+interface GuardianVerifyVoiceTemplateVars {
   /** Number of digits in the verification code. */
   codeDigits: number;
 }
 
-export interface ChannelVerifyReplyVars {
+interface ChannelVerifyReplyVars {
   /** Failure reason (anti-oracle: generic message). Only used for failed template. */
   failureReason?: string;
   /** Drives different success copy for guardian vs trusted contact verification. */

package/src/schedule/integration-status.ts

@@ -1,9 +1,73 @@
 import { hasTwilioCredentials } from "../calls/twilio-rest.js";
+import type { Services } from "../config/schemas/services.js";
 import {
   getConnectionByProvider,
+  getProvider,
   isProviderConnected,
 } from "../oauth/oauth-store.js";
 
+/**
+ * Check whether a provider has an active connection, handling both BYO
+ * (local SQLite) and managed (platform) modes.
+ */
+async function isOAuthProviderConnected(provider: string): Promise<boolean> {
+  const providerRow = getProvider(provider);
+  const managedKey = providerRow?.managedServiceConfigKey;
+
+  if (managedKey) {
+    try {
+      const { ServicesSchema, getServiceMode } =
+        await import("../config/schemas/services.js");
+
+      if (managedKey in ServicesSchema.shape) {
+        const { getConfig } = await import("../config/loader.js");
+        const services: Services = getConfig().services;
+        if (
+          getServiceMode(services, managedKey as keyof Services) === "managed"
+        ) {
+          return isProviderConnectedOnPlatform(provider);
+        }
+      }
+    } catch {
+      // Config unavailable — fall through to BYO check
+    }
+  }
+
+  return isProviderConnected(provider);
+}
+
+/**
+ * Check the platform for active connections for a managed provider.
+ * Returns false on any error (network, auth, etc.) rather than throwing.
+ */
+async function isProviderConnectedOnPlatform(
+  provider: string,
+): Promise<boolean> {
+  try {
+    const { VellumPlatformClient } = await import("../platform/client.js");
+    const client = await VellumPlatformClient.create();
+    if (!client?.platformAssistantId) return false;
+
+    const params = new URLSearchParams();
+    params.set("provider", provider);
+    params.set("status", "ACTIVE");
+
+    const path = `/v1/assistants/${encodeURIComponent(client.platformAssistantId)}/oauth/connections/?${params.toString()}`;
+    const response = await client.fetch(path);
+
+    if (!response.ok) return false;
+
+    const body = (await response.json()) as unknown;
+    const connections = Array.isArray(body)
+      ? body
+      : ((body as Record<string, unknown>).results ?? []);
+
+    return (connections as unknown[]).length > 0;
+  } catch {
+    return false;
+  }
+}
+
 interface IntegrationProbe {
   name: string;
   category: string;
@@ -15,12 +79,12 @@ const INTEGRATION_PROBES: IntegrationProbe[] = [
   {
     name: "Gmail",
     category: "email",
-    isConnected: () => isProviderConnected("google"),
+    isConnected: () => isOAuthProviderConnected("google"),
   },
   {
     name: "Slack",
     category: "messaging",
-    isConnected: () => isProviderConnected("slack"),
+    isConnected: () => isOAuthProviderConnected("slack"),
   },
   {
     name: "Twilio",

package/src/schedule/recurrence-engine.ts

@@ -107,7 +107,10 @@ export function validateRruleSetLines(expression: string): string | null {
 export function isValidScheduleExpression(spec: ScheduleSpec): boolean {
   try {
     if (spec.syntax === "cron") {
-      new Cron(spec.expression, { maxRuns: 0 });
+      new Cron(spec.expression, {
+        maxRuns: 0,
+        timezone: spec.timezone ?? undefined,
+      });
       return true;
     }
 

package/src/schedule/retry-backoff.ts

@@ -0,0 +1,18 @@
+export const DEFAULT_MAX_BACKOFF_MS = 30 * 60 * 1000; // 30 minutes
+
+/**
+ * Compute retry delay with exponential backoff and jitter.
+ * The exponential term is clamped to maxMs BEFORE jitter to prevent
+ * Infinity/NaN for large attempt values, and capped again after jitter
+ * so the result never exceeds maxMs.
+ */
+export function computeRetryDelay(
+  attempt: number,
+  baseMs: number,
+  maxMs: number = DEFAULT_MAX_BACKOFF_MS,
+  random: () => number = Math.random,
+): number {
+  const exponential = Math.min(baseMs * Math.pow(2, attempt), maxMs);
+  const jitter = exponential * 0.2 * (2 * random() - 1);
+  return Math.max(0, Math.min(Math.round(exponential + jitter), maxMs));
+}

package/src/schedule/retry-policy.ts

@@ -0,0 +1,82 @@
+import type { Logger } from "pino";
+
+import { computeRetryDelay } from "./retry-backoff.js";
+
+export interface RetryPolicyJob {
+  id: string;
+  name: string;
+  retryCount: number;
+  maxRetries: number;
+  retryBackoffMs: number;
+}
+
+export type RetryDecision =
+  | { action: "retry"; delayMs: number; nextRetryAt: number }
+  | { action: "exhaust" };
+
+/**
+ * Pure decision function: given a job's retry state, decide whether
+ * to retry with backoff or give up.
+ *
+ * `retryCount` is the PRE-increment value (before completeScheduleRun
+ * bumped it). So `retryCount < maxRetries` allows exactly maxRetries
+ * retries: retryCount 0, 1, …, maxRetries−1 all pass the check.
+ */
+export function decideRetry(
+  job: RetryPolicyJob,
+  now: number = Date.now(),
+): RetryDecision {
+  if (job.retryCount < job.maxRetries) {
+    const delayMs = computeRetryDelay(job.retryCount, job.retryBackoffMs);
+    return { action: "retry", delayMs, nextRetryAt: now + delayMs };
+  }
+  return { action: "exhaust" };
+}
+
+/**
+ * Apply the retry decision to a schedule: schedule a retry or exhaust.
+ * Calls the provided store operations so this module stays decoupled
+ * from direct DB imports.
+ */
+export function applyRetryDecision(params: {
+  job: RetryPolicyJob;
+  isOneShot: boolean;
+  errorMsg: string;
+  decision: RetryDecision;
+  scheduleRetry: (id: string, nextRetryAt: number) => void;
+  failOneShotPermanently: (id: string) => void;
+  resetRetryCount: (id: string) => void;
+  emitAlert: (title: string, summary: string, dedupKey: string) => void;
+  log: Logger;
+}): void {
+  const { job, isOneShot, errorMsg, decision } = params;
+
+  if (decision.action === "retry") {
+    params.scheduleRetry(job.id, decision.nextRetryAt);
+    params.log.info(
+      {
+        jobId: job.id,
+        name: job.name,
+        attempt: job.retryCount + 1,
+        maxRetries: job.maxRetries,
+        delayMs: decision.delayMs,
+      },
+      "Scheduling retry with backoff",
+    );
+  } else {
+    if (isOneShot) {
+      params.failOneShotPermanently(job.id);
+    } else {
+      params.resetRetryCount(job.id);
+    }
+    params.emitAlert(
+      `${job.name}: Retries exhausted`,
+      `Failed after ${job.retryCount + 1} attempt(s): ${errorMsg}`,
+      `schedule-retries-exhausted:${job.id}:${Date.now()}`,
+    );
+    params.log.warn(
+      { jobId: job.id, name: job.name, attempts: job.retryCount + 1 },
+      "Schedule retries exhausted",
+    );
+  }
+}

package/src/schedule/run-script.ts

@@ -38,21 +38,53 @@ export async function runScript(
     env: buildSanitizedEnv(),
   });
 
-  // Race process completion against a timeout
+  // Start consuming streams immediately so buffered output is available even on timeout.
+  // When the process is killed the pipe fds close and these promises resolve on their own.
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+
+  let timedOut = false;
+
   const timeoutPromise = new Promise<never>((_, reject) => {
     const timer = setTimeout(() => {
+      timedOut = true;
       proc.kill("SIGKILL");
       reject(new Error(`Script timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timer.unref();
-    // Clean up timer if process finishes first
     proc.exited.then(() => clearTimeout(timer));
   });
 
-  const exitCode = await Promise.race([proc.exited, timeoutPromise]);
+  /** How long to wait for pipes to drain after SIGKILL before giving up. */
+  const DRAIN_TIMEOUT_MS = 5_000;
+
+  let exitCode: number;
+  try {
+    exitCode = await Promise.race([proc.exited, timeoutPromise]);
+  } catch (err) {
+    if (!timedOut) throw err;
+    // Collect whatever the process wrote before it was killed.
+    // Race each stream against a short drain window — if a background child
+    // process inherited the pipe fd, the stream would otherwise never reach
+    // EOF and block the scheduler tick indefinitely.
+    const empty = (ms: number): Promise<string> =>
+      new Promise((resolve) => setTimeout(() => resolve(""), ms));
+    const [stdoutStr, stderrStr] = await Promise.all([
+      Promise.race([stdoutPromise, empty(DRAIN_TIMEOUT_MS)]),
+      Promise.race([stderrPromise, empty(DRAIN_TIMEOUT_MS)]),
+    ]);
+    const stdout = truncate(stdoutStr);
+    const timeoutMsg = `Script timed out after ${timeoutMs}ms`;
+    const stderr = truncate(stderrStr ? `${timeoutMsg}\n${stderrStr}` : timeoutMsg);
+    log.info(
+      { command, timedOut: true, stdoutLen: stdout.length },
+      "Script timed out",
+    );
+    return { exitCode: 124, stdout, stderr };
+  }
 
-  const stdout = truncate(await new Response(proc.stdout).text());
-  const stderr = truncate(await new Response(proc.stderr).text());
+  const stdout = truncate(await stdoutPromise);
+  const stderr = truncate(await stderrPromise);
 
   log.info(
     { command, exitCode, stdoutLen: stdout.length, stderrLen: stderr.length },

package/src/schedule/schedule-recovery.ts

@@ -0,0 +1,64 @@
+import { getLogger } from "../util/logger.js";
+import { applyRetryDecision, decideRetry } from "./retry-policy.js";
+import {
+  completeScheduleRun,
+  createScheduleRun,
+  failOneShotPermanently,
+  findStaleInFlightJobs,
+  getSchedule,
+  resetRetryCount,
+  scheduleRetry,
+} from "./schedule-store.js";
+
+const log = getLogger("schedule-recovery");
+
+/**
+ * Recover schedules left in an inconsistent state by a prior process crash.
+ * Called once at daemon startup, before the scheduler tick loop starts,
+ * so all "firing" / "running" rows are definitively stale.
+ */
+export function recoverStaleSchedules(): number {
+  const stale = findStaleInFlightJobs(0);
+  if (stale.length === 0) return 0;
+
+  log.info({ count: stale.length }, "Recovering stale in-flight schedules");
+
+  let recovered = 0;
+  for (const { jobId, staleRunId } of stale) {
+    try {
+      const job = getSchedule(jobId);
+      if (!job) continue;
+
+      const errorMsg =
+        "Process terminated during execution (recovered on restart)";
+
+      if (staleRunId) {
+        completeScheduleRun(staleRunId, { status: "error", error: errorMsg });
+      } else {
+        const runId = createScheduleRun(jobId, `recovery:${jobId}`);
+        completeScheduleRun(runId, { status: "error", error: errorMsg });
+      }
+
+      // Use the same retry-or-exhaust path as the scheduler
+      const isOneShot = job.expression == null;
+      const decision = decideRetry(job);
+      applyRetryDecision({
+        job,
+        isOneShot,
+        errorMsg,
+        decision,
+        scheduleRetry,
+        failOneShotPermanently,
+        resetRetryCount,
+        emitAlert: () => {}, // no feed event on startup recovery
+        log,
+      });
+      recovered++;
+    } catch (err) {
+      log.error({ err, jobId }, "Failed to recover stale schedule");
+    }
+  }
+
+  log.info({ recovered }, "Stale schedule recovery complete");
+  return recovered;
+}