@vellumai/assistant 0.5.3 → 0.5.5

package/src/memory/reducer-scheduler.ts

@@ -0,0 +1,242 @@
+/**
+ * Reducer scheduler — synchronous pre-switch/create reduction of the most
+ * recently updated dirty conversation.
+ *
+ * When the user switches conversations or starts a new one, we want the
+ * *previous* conversation's memory to be reduced before the next memory
+ * read. This module exposes {@link reduceBeforeSwitch} which:
+ *
+ *   1. Finds the single most recently updated dirty conversation (excluding
+ *      the target conversation).
+ *   2. Runs the same reduction pipeline the background job uses (load
+ *      unreduced messages, call {@link runReducer}, apply via
+ *      {@link applyReducerResult}).
+ *   3. Awaits the result so the caller can proceed knowing memory is fresh.
+ *
+ * If no eligible dirty conversation exists, the function returns immediately.
+ */
+
+import { and, asc, desc, eq, gte, isNotNull, ne } from "drizzle-orm";
+
+import { getLogger } from "../util/logger.js";
+import { type ConversationRow, getConversation } from "./conversation-crud.js";
+import { getDb } from "./db.js";
+import { type ReducerPromptInput, runReducer } from "./reducer.js";
+import {
+  applyReducerResult,
+  getActiveOpenLoops,
+  getActiveTimeContexts,
+} from "./reducer-store.js";
+import { EMPTY_REDUCER_RESULT } from "./reducer-types.js";
+import { conversations, messages } from "./schema.js";
+
+const log = getLogger("reducer-scheduler");
+
+// ── Internal helpers ────────────────────────────────────────────────
+
+interface MessageRow {
+  id: string;
+  role: string;
+  content: string;
+  createdAt: number;
+}
+
+/**
+ * Find the single most recently updated dirty conversation, excluding
+ * the target conversation. Returns the conversation ID or null if none.
+ */
+export function findMostRecentDirtyConversation(
+  excludeConversationId: string,
+): string | null {
+  const db = getDb();
+  const row = db
+    .select({ id: conversations.id })
+    .from(conversations)
+    .where(
+      and(
+        isNotNull(conversations.memoryDirtyTailSinceMessageId),
+        ne(conversations.id, excludeConversationId),
+      ),
+    )
+    .orderBy(desc(conversations.updatedAt))
+    .limit(1)
+    .get();
+
+  return row?.id ?? null;
+}
+
+/**
+ * Load messages from `dirtyTailMessageId` onward (inclusive), ordered by
+ * createdAt ascending.
+ */
+function loadUnreducedMessages(
+  conversationId: string,
+  dirtyTailMessageId: string,
+): MessageRow[] {
+  const db = getDb();
+
+  const tailMessage = db
+    .select({ createdAt: messages.createdAt })
+    .from(messages)
+    .where(eq(messages.id, dirtyTailMessageId))
+    .get();
+
+  if (!tailMessage) {
+    return [];
+  }
+
+  return db
+    .select({
+      id: messages.id,
+      role: messages.role,
+      content: messages.content,
+      createdAt: messages.createdAt,
+    })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        gte(messages.createdAt, tailMessage.createdAt),
+      ),
+    )
+    .orderBy(asc(messages.createdAt))
+    .all();
+}
+
+/**
+ * Build the `newMessages` array for the reducer input, optionally
+ * prepending the conversation's contextSummary as a synthetic system message.
+ */
+function buildNewMessages(
+  conversation: ConversationRow,
+  unreducedMessages: MessageRow[],
+): Array<{ role: string; content: string }> {
+  const result: Array<{ role: string; content: string }> = [];
+
+  if (conversation.contextSummary) {
+    result.push({
+      role: "system",
+      content: `[Prior context summary] ${conversation.contextSummary}`,
+    });
+  }
+
+  for (const msg of unreducedMessages) {
+    result.push({ role: msg.role, content: msg.content });
+  }
+
+  return result;
+}
+
+// ── Public API ──────────────────────────────────────────────────────
+
+/**
+ * Reduce the most recently updated dirty conversation (excluding
+ * `targetConversationId`) before a conversation switch or create.
+ *
+ * This runs the full reduction pipeline synchronously (awaiting the
+ * provider call) so the caller can proceed knowing memory is fresh.
+ *
+ * Returns the conversation ID that was reduced, or null if none were eligible.
+ */
+export async function reduceBeforeSwitch(
+  targetConversationId: string,
+): Promise<string | null> {
+  const dirtyConversationId =
+    findMostRecentDirtyConversation(targetConversationId);
+
+  if (!dirtyConversationId) {
+    return null;
+  }
+
+  const conversation = getConversation(dirtyConversationId);
+  if (!conversation) {
+    return null;
+  }
+
+  const dirtyTailMessageId = conversation.memoryDirtyTailSinceMessageId;
+  if (!dirtyTailMessageId) {
+    return null;
+  }
+
+  // ── Load unreduced messages ──────────────────────────────────
+  const unreducedMessages = loadUnreducedMessages(
+    dirtyConversationId,
+    dirtyTailMessageId,
+  );
+
+  if (unreducedMessages.length === 0) {
+    log.debug(
+      { conversationId: dirtyConversationId, dirtyTailMessageId },
+      "No messages found from dirty tail — nothing to reduce on switch",
+    );
+    return null;
+  }
+
+  // ── Load active brief-state context ──────────────────────────
+  const scopeId = conversation.memoryScopeId;
+  const now = Date.now();
+
+  const existingTimeContexts = getActiveTimeContexts(scopeId, now);
+  const existingOpenLoops = getActiveOpenLoops(scopeId);
+
+  // ── Build reducer input ──────────────────────────────────────
+  const newMessages = buildNewMessages(conversation, unreducedMessages);
+
+  const reducerInput: ReducerPromptInput = {
+    conversationId: dirtyConversationId,
+    newMessages,
+    existingTimeContexts: existingTimeContexts.map((tc) => ({
+      id: tc.id,
+      summary: tc.summary,
+    })),
+    existingOpenLoops: existingOpenLoops.map((ol) => ({
+      id: ol.id,
+      summary: ol.summary,
+      status: ol.status,
+    })),
+    nowMs: now,
+    scopeId,
+  };
+
+  // ── Run the reducer ──────────────────────────────────────────
+  try {
+    const result = await runReducer(reducerInput);
+
+    if (result === EMPTY_REDUCER_RESULT) {
+      log.debug(
+        { conversationId: dirtyConversationId },
+        "Reducer returned empty result on switch — not advancing checkpoint",
+      );
+      return null;
+    }
+
+    // ── Apply result transactionally ───────────────────────────
+    const lastMessage = unreducedMessages[unreducedMessages.length - 1];
+    applyReducerResult({
+      result,
+      conversationId: dirtyConversationId,
+      scopeId,
+      reducedThroughMessageId: lastMessage.id,
+      now,
+    });
+
+    log.info(
+      {
+        conversationId: dirtyConversationId,
+        reducedThroughMessageId: lastMessage.id,
+        messageCount: unreducedMessages.length,
+        timeContextOps: result.timeContexts.length,
+        openLoopOps: result.openLoops.length,
+      },
+      "Pre-switch memory reduction completed",
+    );
+
+    return dirtyConversationId;
+  } catch (err) {
+    log.warn(
+      { err, conversationId: dirtyConversationId },
+      "Pre-switch memory reduction failed — continuing with switch",
+    );
+    return null;
+  }
+}

package/src/memory/reducer-types.ts

@@ -86,8 +86,15 @@ export interface ReducerResult {
 }
 
 /**
- * An empty result used as fallback when the reducer output is invalid or
- * unparseable. Guarantees no side-effects on the DB.
+ * Sentinel empty result returned when the reducer output is **unparseable**
+ * (not valid JSON, not a JSON object, provider failure, etc.).
+ *
+ * Callers use identity comparison (`=== EMPTY_REDUCER_RESULT`) to detect
+ * true parse failures and skip checkpoint advancement so the job can retry.
+ *
+ * A valid-but-empty model response (e.g. `{}`) returns a normal
+ * `ReducerResult` with all empty arrays — NOT this sentinel — so the
+ * checkpoint advances and the dirty tail is cleared.
  */
 export const EMPTY_REDUCER_RESULT: Readonly<ReducerResult> = Object.freeze({
   timeContexts: Object.freeze([]) as unknown as TimeContextOp[],

package/src/memory/reducer.ts

@@ -5,7 +5,7 @@
  *   1. ReducerPromptInput — structured input for the provider call
  *   2. runReducer — send the transcript span to the LLM and return a typed result
  *   3. parseReducerOutput — raw string -> validated ReducerResult
- *   4. Fallback to EMPTY_REDUCER_RESULT on any invalid output
+ *   4. Fallback to EMPTY_REDUCER_RESULT on unparseable output (parse failures only)
  *
  * The reducer is intentionally side-effect-free: it never writes to the
  * database. Callers are responsible for applying the returned ReducerResult.
@@ -373,13 +373,19 @@ function validateArchiveEpisode(raw: unknown): ArchiveEpisodeCandidate | null {
 /**
  * Parse raw model output into a validated ReducerResult.
  *
- * On any structural error (non-JSON, missing top-level keys, wrong types)
- * the function returns EMPTY_REDUCER_RESULT rather than throwing. Individual
- * invalid operations within an otherwise valid structure are silently dropped
- * to preserve the rest of the result.
+ * On any structural error (non-JSON, not a JSON object) the function returns
+ * {@link EMPTY_REDUCER_RESULT} rather than throwing — callers use identity
+ * comparison (`=== EMPTY_REDUCER_RESULT`) to detect true parse failures and
+ * skip checkpoint advancement.
  *
- * However, if **all four** top-level arrays are absent or not arrays, the
- * entire output is treated as invalid and returns the empty result.
+ * A valid JSON object with no recognized top-level arrays (e.g. `{}`) is
+ * treated as a **valid-but-empty** response — the model simply had nothing
+ * to extract. In this case a normal `ReducerResult` with all empty arrays
+ * is returned so that callers advance the checkpoint and clear the dirty
+ * tail, avoiding an infinite retry loop.
+ *
+ * Individual invalid operations within an otherwise valid structure are
+ * silently dropped to preserve the rest of the result.
  */
 export function parseReducerOutput(raw: string): ReducerResult {
   let parsed: unknown;
@@ -399,22 +405,30 @@ export function parseReducerOutput(raw: string): ReducerResult {
 
   const obj = parsed as Record<string, unknown>;
 
-  // Check that at least one top-level array key exists
+  // Check which top-level array keys are present
   const hasTimeContexts = Array.isArray(obj.timeContexts);
   const hasOpenLoops = Array.isArray(obj.openLoops);
   const hasArchiveObservations = Array.isArray(obj.archiveObservations);
   const hasArchiveEpisodes = Array.isArray(obj.archiveEpisodes);
 
+  // A valid JSON object with no recognized arrays (e.g. `{}`) means the
+  // model had nothing to extract — return a normal (non-sentinel) empty
+  // result so the checkpoint advances.
   if (
     !hasTimeContexts &&
     !hasOpenLoops &&
     !hasArchiveObservations &&
     !hasArchiveEpisodes
   ) {
-    log.warn(
-      "reducer output has no recognized top-level arrays — falling back to empty result",
+    log.debug(
+      "reducer output is valid JSON with no extractions — advancing with empty result",
     );
-    return EMPTY_REDUCER_RESULT;
+    return {
+      timeContexts: [],
+      openLoops: [],
+      archiveObservations: [],
+      archiveEpisodes: [],
+    };
   }
 
   const timeContexts: TimeContextOp[] = [];

package/src/memory/schema/infrastructure.ts

@@ -24,6 +24,7 @@ export const cronJobs = sqliteTable("cron_jobs", {
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
   routingHintsJson: text("routing_hints_json").notNull().default("{}"),
   status: text("status").notNull().default("active"), // 'active' | 'firing' | 'fired' | 'cancelled'
+  quiet: integer("quiet", { mode: "boolean" }).notNull().default(false), // suppress completion notifications
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });

package/src/messaging/provider.ts

@@ -89,6 +89,15 @@ export interface MessagingProvider {
    */
   isConnected?(): Promise<boolean>;
 
+  /**
+   * Custom credential resolution for providers with non-standard credential
+   * paths (e.g. Slack Socket Mode stores tokens under "slack_channel" rather
+   * than the OAuth provider key). When present, getProviderConnection() calls
+   * this instead of resolveOAuthConnection(), giving the provider full control
+   * over credential lookup including fallback strategies.
+   */
+  resolveConnection?(account?: string): Promise<OAuthConnection | string>;
+
   /** Platform-specific capabilities for tool routing (e.g. 'reactions', 'threads', 'labels'). */
   capabilities: Set<string>;
 }

package/src/messaging/providers/slack/adapter.ts

@@ -1,11 +1,15 @@
 /**
  * Slack messaging provider adapter.
  *
- * Maps Slack API responses to the platform-agnostic messaging types
- * and implements the MessagingProvider interface.
+ * Maps Slack API responses to the platform-agnostic messaging types and
+ * implements the MessagingProvider interface.
  */
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
+import { resolveOAuthConnection } from "../../../oauth/connection-resolver.js";
+import { isProviderConnected } from "../../../oauth/oauth-store.js";
+import { credentialKey } from "../../../security/credential-key.js";
+import { getSecureKeyAsync } from "../../../security/secure-keys.js";
 import type { MessagingProvider } from "../../provider.js";
 import type {
   ConnectionInfo,
@@ -112,6 +116,29 @@ export const slackProvider: MessagingProvider = {
   credentialService: "integration:slack",
   capabilities: new Set(["reactions", "threads", "leave_channel"]),
 
+  async isConnected(): Promise<boolean> {
+    // Socket Mode: check for bot token directly in credential store.
+    // The token is the source of truth; the slack_channel connection row
+    // is advisory (backfill can fail non-fatally on startup).
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (botToken) return true;
+    // Preserve existing OAuth path (integration:slack) for backwards compat.
+    return isProviderConnected("integration:slack");
+  },
+
+  async resolveConnection(account?: string): Promise<OAuthConnection | string> {
+    // Socket Mode: return raw bot token if available.
+    // Token presence is sufficient — no connection row required.
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (botToken) return botToken;
+    // Preserve existing OAuth path (integration:slack) for backwards compat.
+    return resolveOAuthConnection("integration:slack", { account });
+  },
+
   async testConnection(
     connectionOrToken: OAuthConnection | string,
   ): Promise<ConnectionInfo> {

package/src/oauth/connection-resolver.test.ts

@@ -8,12 +8,7 @@ let mockProvider: Record<string, unknown> | undefined;
 let mockConnection: Record<string, unknown> | undefined;
 let mockAccessToken: string | undefined;
 let mockConfig: Record<string, unknown> = {};
-let mockManagedProxyCtx = {
-  enabled: false,
-  platformBaseUrl: "",
-  assistantApiKey: "",
-};
-let mockAssistantId = "";
+let mockPlatformClient: Record<string, unknown> | null = null;
 
 // ---------------------------------------------------------------------------
 // Module mocks (must precede imports of the module under test)
@@ -48,12 +43,10 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
 }));
 
-mock.module("../config/env.js", () => ({
-  getPlatformAssistantId: () => mockAssistantId,
-}));
-
-mock.module("../providers/managed-proxy/context.js", () => ({
-  resolveManagedProxyContext: async () => mockManagedProxyCtx,
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => mockPlatformClient,
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -68,6 +61,22 @@ import { PlatformOAuthConnection } from "./platform-connection.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
+function makeMockClient() {
+  return {
+    baseUrl: "https://platform.example.com",
+    assistantApiKey: "sk-test-key",
+    platformAssistantId: "asst-123",
+    fetch: mock(async () => {
+      return new Response(
+        JSON.stringify({
+          results: [{ id: "platform-conn-1", account_label: null }],
+        }),
+        { status: 200 },
+      );
+    }),
+  };
+}
+
 function setupDefaults(): void {
   mockProvider = {
     providerKey: "integration:google",
@@ -100,12 +109,7 @@ function setupDefaults(): void {
       "google-oauth": { mode: "managed" },
     },
   };
-  mockManagedProxyCtx = {
-    enabled: true,
-    platformBaseUrl: "https://platform.example.com",
-    assistantApiKey: "sk-test-key",
-  };
-  mockAssistantId = "asst-123";
+  mockPlatformClient = makeMockClient();
 }
 
 // ---------------------------------------------------------------------------

package/src/oauth/connection-resolver.ts

@@ -1,13 +1,15 @@
-import { getPlatformAssistantId } from "../config/env.js";
 import { getConfig } from "../config/loader.js";
 import { type Services, ServicesSchema } from "../config/schemas/services.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { VellumPlatformClient } from "../platform/client.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
+import { getLogger } from "../util/logger.js";
 import { BYOOAuthConnection } from "./byo-connection.js";
 import type { OAuthConnection } from "./connection.js";
 import { getActiveConnection, getProvider } from "./oauth-store.js";
 import { PlatformOAuthConnection } from "./platform-connection.js";
 
+const log = getLogger("connection-resolver");
+
 export interface ResolveOAuthConnectionOptions {
   /** OAuth app client ID — narrows to a specific app when multiple BYO apps
    *  exist for the same provider. */
@@ -46,16 +48,32 @@ export async function resolveOAuthConnection(
   if (managedKey && managedKey in ServicesSchema.shape) {
     const services: Services = getConfig().services;
     if (services[managedKey as keyof Services].mode === "managed") {
-      const ctx = await resolveManagedProxyContext();
-      const assistantId = getPlatformAssistantId();
+      const client = await VellumPlatformClient.create();
+      if (!client || !client.platformAssistantId) {
+        const detail = !client
+          ? "missing platform prerequisites"
+          : "missing assistant ID";
+        throw new Error(
+          `Platform-managed connection for "${providerKey}" cannot be created: ${detail}. ` +
+            `Log in to the Vellum platform or switch to using your own OAuth app.`,
+        );
+      }
+
+      const providerSlug = providerKey.replace(/^integration:/, "");
+
+      const connectionId = await resolvePlatformConnectionId({
+        client,
+        provider: providerSlug,
+        account,
+      });
+
       return new PlatformOAuthConnection({
         id: providerKey,
         providerKey,
         externalId: providerKey,
         accountInfo: account ?? null,
-        assistantId,
-        platformBaseUrl: ctx.platformBaseUrl,
-        apiKey: ctx.assistantApiKey,
+        client,
+        connectionId,
       });
     }
   }
@@ -98,3 +116,70 @@ export async function resolveOAuthConnection(
     accountInfo: conn.accountInfo,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Platform connection ID resolution
+// ---------------------------------------------------------------------------
+
+interface ResolvePlatformConnectionIdOptions {
+  client: VellumPlatformClient;
+  provider: string;
+  account?: string;
+}
+
+/**
+ * Fetch the platform-side connection ID for a managed provider by calling
+ * the List Connections endpoint.
+ */
+async function resolvePlatformConnectionId(
+  options: ResolvePlatformConnectionIdOptions,
+): Promise<string> {
+  const { client, provider, account } = options;
+
+  const params = new URLSearchParams();
+  params.set("provider", provider);
+  params.set("status", "ACTIVE");
+  if (account) {
+    params.set("account_identifier", account);
+  }
+
+  const path = `/v1/assistants/${client.platformAssistantId}/oauth/connections/?${params.toString()}`;
+  const response = await client.fetch(path);
+
+  if (!response.ok) {
+    log.error(
+      { status: response.status, provider },
+      "Failed to list platform OAuth connections",
+    );
+    throw new Error(
+      `Failed to resolve platform connection for "${provider}": HTTP ${response.status}`,
+    );
+  }
+
+  const body = (await response.json()) as {
+    results?: Array<{ id: string; account_label?: string }>;
+  };
+  const connections = body.results ?? [];
+
+  if (connections.length === 0) {
+    throw new Error(
+      `No active platform OAuth connection found for provider "${provider}"` +
+        (account ? ` with account "${account}"` : "") +
+        ". Connect the service on the Vellum platform first.",
+    );
+  }
+
+  if (connections.length > 1 && !account) {
+    log.warn(
+      {
+        provider,
+        count: connections.length,
+        selectedId: connections[0].id,
+      },
+      "Multiple active platform connections found; using the most recently created. " +
+        "Pass an account option to select a specific connection.",
+    );
+  }
+
+  return connections[0].id;
+}