@vellumai/assistant 0.8.2 → 0.8.4

package/src/runtime/routes/__tests__/slack-channel-routes.test.ts

@@ -0,0 +1,266 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+type MockSlackInfo = {
+  id: string;
+  name?: string;
+  nameNormalized?: string;
+} | null;
+
+type MockSlackResult = MockSlackInfo | { slackError: string };
+
+const slackInfoCalls: string[] = [];
+let slackInfoImpl: (channelId: string) => Promise<MockSlackResult> = async () =>
+  null;
+const syncInvalidations: string[][] = [];
+const originalFetch = globalThis.fetch;
+
+mock.module("../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async () => "xoxb-test",
+}));
+
+mock.module("../../sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: async (tags: string[]) => {
+    syncInvalidations.push([...tags]);
+  },
+}));
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../../../daemon/message-types/sync.js";
+import { createConversation } from "../../../memory/conversation-crud.js";
+import { getDb, resetDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import {
+  getBindingByConversation,
+  upsertBinding,
+} from "../../../memory/external-conversation-store.js";
+import { ROUTES } from "../slack-channel-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+initializeDb();
+
+interface ResolveResponse {
+  channelId: string;
+  channelName?: string;
+  cached: boolean;
+  resolved: boolean;
+  reason?: string;
+}
+
+function resolveHandler(): RouteDefinition["handler"] {
+  const route = ROUTES.find(
+    (r) => r.operationId === "slack_channel_name_resolve",
+  );
+  if (!route) throw new Error("slack_channel_name_resolve route not found");
+  return route.handler;
+}
+
+const handler = resolveHandler();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversations");
+}
+
+function createBoundConversation(input: {
+  sourceChannel?: string;
+  externalChatId: string;
+  externalChatName?: string | null;
+  externalThreadId?: string | null;
+  externalUserId?: string | null;
+  displayName?: string | null;
+  username?: string | null;
+}): string {
+  const conversation = createConversation("Slack route test");
+  upsertBinding({
+    conversationId: conversation.id,
+    sourceChannel: input.sourceChannel ?? "slack",
+    externalChatId: input.externalChatId,
+    externalChatName: input.externalChatName,
+    externalThreadId: input.externalThreadId,
+    externalUserId: input.externalUserId,
+    displayName: input.displayName,
+    username: input.username,
+  });
+  return conversation.id;
+}
+
+async function resolve(conversationId: string): Promise<ResolveResponse> {
+  return (await handler({
+    pathParams: { conversationId },
+  })) as ResolveResponse;
+}
+
+function mockSlackFetch(): void {
+  globalThis.fetch = mock(async (input) => {
+    const url = new URL(String(input));
+    if (url.pathname !== "/api/conversations.info") {
+      throw new Error(`Unexpected Slack API request: ${url.pathname}`);
+    }
+
+    const channelId = url.searchParams.get("channel") ?? "";
+    slackInfoCalls.push(channelId);
+    const result = await slackInfoImpl(channelId);
+    if (result && "slackError" in result) {
+      return Response.json({ ok: false, error: result.slackError });
+    }
+
+    return Response.json({
+      ok: true,
+      channel: result
+        ? {
+            id: result.id,
+            name: result.name,
+            name_normalized: result.nameNormalized,
+          }
+        : undefined,
+    });
+  }) as unknown as typeof fetch;
+}
+
+beforeEach(() => {
+  clearTables();
+  slackInfoCalls.length = 0;
+  syncInvalidations.length = 0;
+  slackInfoImpl = async () => null;
+  mockSlackFetch();
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+  resetDb();
+  mock.restore();
+});
+
+describe("slack_channel_name_resolve", () => {
+  test("returns cached friendly name without calling Slack", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CACHED123",
+      externalChatName: "team-updates",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CACHED123",
+      channelName: "team-updates",
+      cached: true,
+      resolved: true,
+    });
+    expect(slackInfoCalls).toEqual([]);
+  });
+
+  test("resolves an unresolved channel ID and persists the returned name", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CRESOLVE123",
+      externalChatName: "CRESOLVE123",
+      externalThreadId: "1710000000.000100",
+      externalUserId: "U123",
+      displayName: "Alice",
+      username: "alice",
+    });
+    slackInfoImpl = async (channelId) => ({
+      id: channelId,
+      name: "engineering",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(slackInfoCalls).toEqual(["CRESOLVE123"]);
+    expect(result).toEqual({
+      channelId: "CRESOLVE123",
+      channelName: "engineering",
+      cached: false,
+      resolved: true,
+    });
+
+    const updated = getBindingByConversation(conversationId);
+    expect(updated?.externalChatName).toBe("engineering");
+    expect(updated?.externalThreadId).toBe("1710000000.000100");
+    expect(updated?.externalUserId).toBe("U123");
+    expect(updated?.displayName).toBe("Alice");
+    expect(updated?.username).toBe("alice");
+  });
+
+  test("publishes conversation sync tags after persisting a returned name", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CSYNC123",
+      externalChatName: "CSYNC123",
+    });
+    slackInfoImpl = async (channelId) => ({
+      id: channelId,
+      nameNormalized: "team-sync",
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CSYNC123",
+      channelName: "team-sync",
+      cached: false,
+      resolved: true,
+    });
+    expect(syncInvalidations).toContainEqual([
+      SYNC_TAGS.conversationsList,
+      conversationMetadataSyncTag(conversationId),
+    ]);
+  });
+
+  test("does not call Slack for DM bindings", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "D123",
+      externalChatName: null,
+    });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "D123",
+      cached: false,
+      resolved: false,
+      reason: "dm",
+    });
+    expect(slackInfoCalls).toEqual([]);
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      null,
+    );
+  });
+
+  test("rejects non-Slack bindings", async () => {
+    const conversationId = createBoundConversation({
+      sourceChannel: "telegram",
+      externalChatId: "chat-123",
+    });
+
+    await expect(resolve(conversationId)).rejects.toMatchObject({
+      code: "NOT_FOUND",
+      statusCode: 404,
+    });
+    expect(slackInfoCalls).toEqual([]);
+  });
+
+  test("returns unresolved on Slack API failure without mutating the binding", async () => {
+    const conversationId = createBoundConversation({
+      externalChatId: "CFAIL123",
+      externalChatName: "CFAIL123",
+    });
+    const before = getBindingByConversation(conversationId);
+    slackInfoImpl = async () => ({ slackError: "missing_scope" });
+
+    const result = await resolve(conversationId);
+
+    expect(result).toEqual({
+      channelId: "CFAIL123",
+      cached: false,
+      resolved: false,
+      reason: "permission",
+    });
+    expect(slackInfoCalls).toEqual(["CFAIL123"]);
+
+    const after = getBindingByConversation(conversationId);
+    expect(after?.externalChatName).toBe("CFAIL123");
+    expect(after?.updatedAt).toBe(before?.updatedAt);
+  });
+});

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

@@ -78,7 +78,10 @@ function handleConfirm({ body }: RouteHandlerArgs) {
   // ACP permissions: resolve directly without a Conversation object.
   // No PermissionPrompter involved, so the route owns deregistration.
   if (interaction.directResolve) {
-    pendingInteractions.resolve(requestId);
+    pendingInteractions.resolve(
+      requestId,
+      effectiveDecision === "allow" ? "approved" : "rejected",
+    );
     interaction.directResolve(effectiveDecision as UserDecision);
     return { accepted: true };
   }

package/src/runtime/routes/channel-availability-routes.ts

@@ -17,12 +17,14 @@
 
 import { z } from "zod";
 
+import { isA2AEnabled } from "../../a2a/feature-gate.js";
 import {
   CHANNEL_IDS,
   CHANNEL_METADATA,
   type ChannelId,
   type ChannelInfo,
 } from "../../channels/types.js";
+import { getConfig } from "../../config/loader.js";
 import { VellumPlatformClient } from "../../platform/client.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -75,6 +77,9 @@ async function handleGetChannelAvailability(
   if (await hasRegisteredInbox()) {
     ids.push("email");
   }
+  if (isA2AEnabled(getConfig())) {
+    ids.push("a2a");
+  }
   // CHANNEL_METADATA is `Partial<Record<ChannelId, ChannelInfo>>` because
   // unsurfaced channels deliberately have no metadata. `ids` only ever
   // contains channels that BASE_AVAILABLE_CHANNELS / the email branch

package/src/runtime/routes/chatgpt-subscription-auth-routes.ts

@@ -0,0 +1,246 @@
+/**
+ * Route definitions for ChatGPT subscription OAuth authentication.
+ *
+ * POST /v1/inference/chatgpt-subscription/auth — generate a PKCE authorize
+ *   URL for the user to visit. Returns `{ authorize_url, state }`.
+ *
+ * POST /v1/inference/chatgpt-subscription/auth/exchange — accept the
+ *   authorization code + state from the redirect, exchange for tokens,
+ *   store in CES, and upsert the provider connection.
+ */
+
+import { z } from "zod";
+
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
+import { getConfigReadOnly } from "../../config/loader.js";
+import { getDb } from "../../memory/db-connection.js";
+import {
+  createConnection,
+  getConnection,
+  updateConnection,
+} from "../../providers/inference/connections.js";
+import type { OAuth2Config } from "../../security/oauth2.js";
+import {
+  exchangeCodeForTokens,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generateState,
+} from "../../security/oauth2.js";
+import { setSecureKeyAsync } from "../../security/secure-keys.js";
+import { getLogger } from "../../util/logger.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+function requireFeatureFlag() {
+  const config = getConfigReadOnly();
+  if (!isAssistantFeatureFlagEnabled("chatgpt-subscription-auth", config)) {
+    throw new BadRequestError(
+      "ChatGPT subscription auth is not enabled for this assistant.",
+    );
+  }
+}
+
+const log = getLogger("chatgpt-subscription-auth");
+
+// ---------------------------------------------------------------------------
+// OAuth config
+// ---------------------------------------------------------------------------
+
+const OPENAI_OAUTH_CONFIG: OAuth2Config = {
+  authorizeUrl: "https://auth.openai.com/oauth/authorize",
+  tokenExchangeUrl: "https://auth.openai.com/oauth/token",
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  scopes: ["openid", "profile", "email", "offline_access"],
+  scopeSeparator: " ",
+  authorizeParams: { id_token_add_organizations: "true" },
+};
+
+const REDIRECT_URI = "http://localhost:1455/auth/callback";
+const CONNECTION_NAME = "chatgpt-subscription";
+
+// ---------------------------------------------------------------------------
+// Module-level PKCE state storage
+// ---------------------------------------------------------------------------
+
+interface PendingAuth {
+  codeVerifier: string;
+  createdAt: number;
+}
+
+const pendingAuths = new Map<string, PendingAuth>();
+
+const PENDING_AUTH_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+/** Remove entries older than 10 minutes. */
+function cleanupExpiredEntries(): void {
+  const cutoff = Date.now() - PENDING_AUTH_TTL_MS;
+  for (const [key, entry] of pendingAuths) {
+    if (entry.createdAt < cutoff) {
+      pendingAuths.delete(key);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+async function handleStartAuth(_args: RouteHandlerArgs) {
+  requireFeatureFlag();
+  cleanupExpiredEntries();
+
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = generateState();
+
+  pendingAuths.set(state, { codeVerifier, createdAt: Date.now() });
+
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: OPENAI_OAUTH_CONFIG.clientId,
+    redirect_uri: REDIRECT_URI,
+    scope: OPENAI_OAUTH_CONFIG.scopes.join(
+      OPENAI_OAUTH_CONFIG.scopeSeparator,
+    ),
+    state,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    ...OPENAI_OAUTH_CONFIG.authorizeParams,
+  });
+
+  const authorizeUrl = `${OPENAI_OAUTH_CONFIG.authorizeUrl}?${params.toString()}`;
+
+  return { authorize_url: authorizeUrl, state };
+}
+
+async function handleExchange(args: RouteHandlerArgs) {
+  requireFeatureFlag();
+  const { code, state } = args.body as { code: string; state: string };
+
+  const pending = pendingAuths.get(state);
+  if (!pending) {
+    throw new Error(
+      "Invalid or expired state parameter. Please restart the auth flow.",
+    );
+  }
+
+  pendingAuths.delete(state);
+
+  // Check TTL
+  if (Date.now() - pending.createdAt > PENDING_AUTH_TTL_MS) {
+    throw new Error("Auth flow expired. Please restart the auth flow.");
+  }
+
+  const { tokens } = await exchangeCodeForTokens(
+    OPENAI_OAUTH_CONFIG,
+    code,
+    REDIRECT_URI,
+    pending.codeVerifier,
+  );
+
+  // Store tokens in CES
+  const accessStored = await setSecureKeyAsync(
+    "credential/chatgpt/access_token",
+    tokens.accessToken,
+  );
+  if (!accessStored) {
+    log.error("Failed to store ChatGPT access token in CES");
+    throw new Error("Failed to store access token");
+  }
+
+  if (tokens.refreshToken) {
+    const refreshStored = await setSecureKeyAsync(
+      "credential/chatgpt/refresh_token",
+      tokens.refreshToken,
+    );
+    if (!refreshStored) {
+      log.error("Failed to store ChatGPT refresh token in CES");
+      throw new Error("Failed to store refresh token");
+    }
+  }
+
+  if (tokens.expiresIn) {
+    const expiresAt = Math.floor(Date.now() / 1000 + tokens.expiresIn);
+    await setSecureKeyAsync(
+      "credential/chatgpt/expires_at",
+      String(expiresAt),
+    );
+  }
+
+  // Upsert provider connection
+  const db = getDb();
+  const authInput = {
+    type: "oauth_subscription" as const,
+    credential: "credential/chatgpt/access_token",
+  };
+
+  const existing = getConnection(db, CONNECTION_NAME);
+  if (existing) {
+    const updateResult = updateConnection(db, CONNECTION_NAME, {
+      auth: authInput,
+    });
+    if (!updateResult.ok) {
+      log.error(
+        { error: updateResult.error },
+        "Failed to update chatgpt-subscription connection",
+      );
+      throw new Error("Failed to update connection");
+    }
+  } else {
+    const createResult = createConnection(db, {
+      name: CONNECTION_NAME,
+      provider: "openai",
+      auth: authInput,
+    });
+    if (!createResult.ok) {
+      log.error(
+        { error: createResult.error },
+        "Failed to create chatgpt-subscription connection",
+      );
+      throw new Error("Failed to create connection");
+    }
+  }
+
+  log.info("ChatGPT subscription auth flow completed successfully");
+  return { ok: true };
+}
+
+// ---------------------------------------------------------------------------
+// Route definitions
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "inference_chatgpt_subscription_auth",
+    endpoint: "inference/chatgpt-subscription/auth",
+    method: "POST",
+    policyKey: "inference/provider-connections",
+    summary: "Start ChatGPT subscription OAuth PKCE flow",
+    description:
+      "Generate a PKCE authorize URL for ChatGPT subscription auth. Returns the URL and state for the client to open in a browser.",
+    tags: ["inference"],
+    responseBody: z.object({
+      authorize_url: z.string(),
+      state: z.string(),
+    }),
+    handler: handleStartAuth,
+  },
+  {
+    operationId: "inference_chatgpt_subscription_auth_exchange",
+    endpoint: "inference/chatgpt-subscription/auth/exchange",
+    method: "POST",
+    policyKey: "inference/provider-connections",
+    summary: "Exchange ChatGPT subscription OAuth authorization code",
+    description:
+      "Accept an authorization code and state from the OAuth redirect, exchange it for tokens, store them in CES, and upsert the provider connection.",
+    tags: ["inference"],
+    requestBody: z.object({
+      code: z.string(),
+      state: z.string(),
+    }),
+    responseBody: z.object({
+      ok: z.boolean(),
+    }),
+    handler: handleExchange,
+  },
+];

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

@@ -17,11 +17,16 @@ import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
 import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
+import {
+  getMessageRoleStatsByConversation,
+  listConversationsBySource,
+} from "../../memory/conversation-queries.js";
 import {
   enqueueMemoryJob,
   hasActiveJobOfType,
 } from "../../memory/jobs-store.js";
 import { GRAPH_MAINTENANCE_CHECKPOINTS } from "../../memory/jobs-worker.js";
+import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -111,4 +116,99 @@ export const ROUTES: RouteDefinition[] = [
       return { success: true, ran: true, jobId };
     },
   },
+  {
+    operationId: "listConsolidationRuns",
+    endpoint: "consolidation/runs",
+    method: "GET",
+    policyKey: "consolidation",
+    summary: "List consolidation runs",
+    description:
+      "Return recent memory v2 consolidation conversations as run records. " +
+      "Each consolidation dispatch creates exactly one background conversation " +
+      "tagged with `source = memory_v2_consolidation`; that conversation IS " +
+      "the run. Synthetic fields: `id` mirrors `conversationId` (no separate " +
+      "run row exists), `scheduledFor` and `startedAt` both equal " +
+      "`conversation.createdAt` (no separate schedule timestamp), " +
+      "`finishedAt` is the `createdAt` of the latest assistant message in " +
+      "the conversation (NOT `conversation.lastMessageAt`, which the kickoff " +
+      "user prompt bumps before the agent runs). `status` is `'ok'` when " +
+      "the conversation has at least one assistant message — i.e. positive " +
+      "evidence the agent emitted output — otherwise `'running'`. This is a " +
+      "weaker signal than heartbeat's `'ok'`: without a dedicated runs " +
+      "table we cannot distinguish 'ran cleanly' from 'crashed after " +
+      "emitting at least one assistant message'. `skipReason` and `error` " +
+      "are always null — skipped runs (lock held, disabled, empty buffer) " +
+      "never create a conversation, and run failure detail is not stored " +
+      "on the conversation row. Shape mirrors `heartbeat/runs` so the " +
+      "schedules settings UI can reuse its run-row component.",
+    tags: ["consolidation"],
+    queryParams: [
+      {
+        name: "limit",
+        schema: { type: "integer" },
+        description: "Max runs to return (default 20, max 100)",
+      },
+    ],
+    responseBody: z.object({
+      runs: z
+        .array(
+          z.object({
+            id: z.string(),
+            scheduledFor: z.number(),
+            startedAt: z.number().nullable(),
+            finishedAt: z.number().nullable(),
+            durationMs: z.number().nullable(),
+            status: z.enum(["ok", "running"]),
+            skipReason: z.string().nullable(),
+            error: z.string().nullable(),
+            conversationId: z.string().nullable(),
+            createdAt: z.number(),
+          }),
+        )
+        .describe("Consolidation run records"),
+    }),
+    handler: async ({ queryParams }: RouteHandlerArgs) => {
+      const params = queryParams ?? {};
+      const rawLimit = Number(params.limit ?? 20);
+      const limit = Number.isFinite(rawLimit)
+        ? Math.min(Math.max(Math.floor(rawLimit), 1), 100)
+        : 20;
+      const rows = listConversationsBySource(
+        MEMORY_V2_CONSOLIDATION_SOURCE,
+        limit,
+      );
+      // Aggregate assistant-message stats in one batched query: presence of
+      // an assistant message is the strongest "agent emitted output" signal
+      // available without a dedicated consolidation runs table. The kickoff
+      // user prompt is persisted via `addMessage` before the agent run,
+      // which bumps `conversations.lastMessageAt` — so that field cannot
+      // be used to infer completion.
+      const assistantStats = getMessageRoleStatsByConversation(
+        rows.map((r) => r.id),
+        "assistant",
+      );
+      return {
+        runs: rows.map((c) => {
+          const stat = assistantStats.get(c.id);
+          const hasAssistantOutput = (stat?.count ?? 0) > 0;
+          const finishedAt = hasAssistantOutput ? stat!.lastAt : null;
+          return {
+            id: c.id,
+            scheduledFor: c.createdAt,
+            startedAt: c.createdAt,
+            finishedAt,
+            durationMs:
+              finishedAt != null ? finishedAt - c.createdAt : null,
+            status: (hasAssistantOutput ? "ok" : "running") as
+              | "ok"
+              | "running",
+            skipReason: null,
+            error: null,
+            conversationId: c.id,
+            createdAt: c.createdAt,
+          };
+        }),
+      };
+    },
+  },
 ];