@vellumai/assistant 0.8.2 → 0.8.3

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,
+          };
+        }),
+      };
+    },
+  },
 ];

package/src/runtime/routes/conversation-query-routes.ts

@@ -59,12 +59,20 @@ import {
   getConversation,
   getMessageById,
 } from "../../memory/conversation-crud.js";
+import { getDb } from "../../memory/db-connection.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
 import { getMemoryRecallLogByMessageIds } from "../../memory/memory-recall-log-store.js";
 import { getMemoryV2ActivationLogByMessageIds } from "../../memory/memory-v2-activation-log-store.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../memory/v2/constants.js";
+import {
+  createConnection,
+  listConnections,
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
+} from "../../providers/inference/connections.js";
+import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
 import { initializeProviders } from "../../providers/registry.js";
+import { credentialKey } from "../../security/credential-key.js";
 import { validateAllowlistFile } from "../../security/secret-allowlist.js";
 import { resolvePricingForUsage } from "../../util/pricing.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
@@ -379,13 +387,42 @@ function readPlainObject(value: unknown): Record<string, unknown> | undefined {
 
 function handleGetConfig() {
   try {
-    return applyContextDefaultsToRawConfig(loadRawConfig());
+    const config = applyContextDefaultsToRawConfig(loadRawConfig());
+    enrichProfilesWithVisionFlag(config);
+    return config;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new InternalError(`Failed to read config: ${message}`);
   }
 }
 
+/**
+ * Annotate each profile in `config.llm.profiles` with `supportsVision`
+ * resolved from the model catalog. The flag is wire-only — it is never
+ * persisted to disk. Unknown (provider, model) pairs default to `true`
+ * (fail-open) so image upload remains available for custom / unlisted models.
+ */
+function enrichProfilesWithVisionFlag(config: unknown): void {
+  const root = readPlainObject(config);
+  if (!root) return;
+  const llm = readPlainObject(root.llm);
+  if (!llm) return;
+  const profiles = readPlainObject(llm.profiles);
+  if (!profiles) return;
+
+  for (const profile of Object.values(profiles)) {
+    const entry = readPlainObject(profile);
+    if (!entry) continue;
+    const provider = entry.provider;
+    const model = entry.model;
+    if (typeof provider !== "string" || typeof model !== "string") continue;
+
+    const catalogProvider = PROVIDER_CATALOG.find((p) => p.id === provider);
+    const catalogModel = catalogProvider?.models.find((m) => m.id === model);
+    entry.supportsVision = catalogModel?.supportsVision ?? true;
+  }
+}
+
 /**
  * Return the JSON Schema for the assistant config (full or scoped).
  *
@@ -617,6 +654,36 @@ async function handleReplaceInferenceProfile({
       );
     }
   }
+  // When the UI sends provider but no provider_connection ("Any active X
+  // connection"), derive the connection now so the config deep-merge doesn't
+  // inherit a stale connection from the default layer.
+  const fragment = parsed.data as Record<string, unknown>;
+  if (!isManaged && fragment.provider && !fragment.provider_connection) {
+    const provider = fragment.provider as string;
+    const db = getDb();
+    const candidates = listConnections(db, { provider });
+    const active = candidates.find((c) => c.status === "active");
+    if (active) {
+      fragment.provider_connection = active.name;
+    } else if (!PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)) {
+      const connectionName = `${provider}-personal`;
+      const isKeyless = provider === "ollama";
+      const result = createConnection(db, {
+        name: connectionName,
+        provider,
+        auth: isKeyless
+          ? { type: "none" }
+          : {
+              type: "api_key",
+              credential: credentialKey(provider, "api_key"),
+            },
+      });
+      if (result.ok) {
+        fragment.provider_connection = connectionName;
+      }
+    }
+  }
+
   const raw = loadRawConfig();
   if (isManaged) {
     // Partial overlay: keep every existing key intact, only update label
@@ -624,17 +691,9 @@ async function handleReplaceInferenceProfile({
     // here would wipe the UI-owned seed fields (provider, model, advanced
     // params) because that function assumes the body carries the full UI
     // surface.
-    patchManagedProfileFields(
-      raw,
-      name,
-      parsed.data as Record<string, unknown>,
-    );
+    patchManagedProfileFields(raw, name, fragment);
   } else {
-    replaceInferenceProfileConfig(
-      raw,
-      name,
-      parsed.data as Record<string, unknown>,
-    );
+    replaceInferenceProfileConfig(raw, name, fragment);
   }
   // Route through `commitConfigWrite` so profile edits flow through the
   // post-write side effects shared with `handlePatchConfig` /

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

@@ -101,6 +101,7 @@ import { writeOnboardingSection } from "../../prompts/persona-resolver.js";
 import { getConfiguredProvider } from "../../providers/provider-send-message.js";
 import type { Provider } from "../../providers/types.js";
 import { checkIngressForSecrets } from "../../security/secret-ingress.js";
+import { getSubagentManager } from "../../subagent/index.js";
 import { getLogger } from "../../util/logger.js";
 import {
   getInterfacesDir,
@@ -1492,6 +1493,12 @@ export async function handleSendMessage(
   // that can service host_browser_request events; we restore that single
   // proxy explicitly below without relaxing `hasNoClient`.
   conversation.updateClient(broadcastMessage, !isInteractive);
+  if (isInteractive) {
+    getSubagentManager().updateParentSender(
+      mapping.conversationId,
+      broadcastMessage,
+    );
+  }
 
   // ── Canned first-greeting fast path ──
   // On a completely fresh workspace, skip LLM inference for the macOS

package/src/runtime/routes/index.ts

@@ -72,6 +72,7 @@ import { ROUTES as IMAGE_GENERATION_ROUTES } from "./image-generation-routes.js"
 import { ROUTES as INFERENCE_PROFILE_SESSION_ROUTES } from "./inference-profile-session-routes.js";
 import { ROUTES as INFERENCE_PROVIDER_CONNECTION_ROUTES } from "./inference-provider-connection-routes.js";
 import { ROUTES as INFERENCE_SEND_ROUTES } from "./inference-send-routes.js";
+import { ROUTES as A2A_ROUTES } from "./integrations/a2a.js";
 import { ROUTES as SLACK_CHANNEL_ROUTES } from "./integrations/slack/channel.js";
 import { ROUTES as SLACK_SHARE_ROUTES } from "./integrations/slack/share.js";
 import { ROUTES as TELEGRAM_ROUTES } from "./integrations/telegram.js";
@@ -223,6 +224,7 @@ export const ROUTES: RouteDefinition[] = [
   ...SECRET_ROUTES,
   ...SETTINGS_ROUTES,
   ...SKILL_ROUTES,
+  ...A2A_ROUTES,
   ...SLACK_CHANNEL_ROUTES,
   ...SLACK_SHARE_ROUTES,
   ...STT_ROUTES,

package/src/runtime/routes/inference-provider-connection-routes.ts

@@ -10,10 +10,13 @@
 
 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 {
   AuthSchema,
+  type ConnectionModel,
+  ConnectionModelSchema,
   ConnectionProviderSchema,
   ConnectionStatusSchema,
   ProviderConnectionSchema,
@@ -35,6 +38,75 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 // ---------------------------------------------------------------------------
 
 const providerConnectionResponseSchema = ProviderConnectionSchema;
+const OPENAI_COMPATIBLE_ENDPOINTS_FLAG = "openai-compatible-endpoints";
+
+function openAICompatibleEndpointsEnabled(): boolean {
+  return isAssistantFeatureFlagEnabled(
+    OPENAI_COMPATIBLE_ENDPOINTS_FLAG,
+    getConfigReadOnly(),
+  );
+}
+
+function rejectDisabledOpenAICompatibleProvider(provider: string): void {
+  if (provider !== "openai-compatible") return;
+  if (openAICompatibleEndpointsEnabled()) return;
+  throw new BadRequestError(
+    "OpenAI-compatible endpoints are disabled. Enable the openai-compatible-endpoints feature flag to configure this provider.",
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Custom provider field parsing (openai-compatible base_url + models)
+// ---------------------------------------------------------------------------
+
+function parseCustomProviderFields(body: Record<string, unknown>): {
+  baseUrl?: string | null;
+  models?: ConnectionModel[] | null;
+} {
+  const out: {
+    baseUrl?: string | null;
+    models?: ConnectionModel[] | null;
+  } = {};
+
+  if ("base_url" in body) {
+    const raw = body.base_url;
+    if (raw === null) {
+      out.baseUrl = null;
+    } else if (typeof raw === "string" && raw.length > 0) {
+      try {
+        const parsed = new URL(raw);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+          throw new BadRequestError(`Invalid base_url: must be an http(s) URL`);
+        }
+      } catch (err) {
+        if (err instanceof BadRequestError) throw err;
+        throw new BadRequestError(
+          `Invalid base_url: must be a valid http(s) URL`,
+        );
+      }
+      out.baseUrl = raw;
+    } else {
+      throw new BadRequestError(
+        `Invalid base_url: must be a non-empty string or null`,
+      );
+    }
+  }
+
+  if ("models" in body) {
+    const raw = body.models;
+    if (raw === null) {
+      out.models = null;
+    } else {
+      const parsed = z.array(ConnectionModelSchema).safeParse(raw);
+      if (!parsed.success) {
+        throw new BadRequestError(`Invalid models: ${parsed.error.message}`);
+      }
+      out.models = parsed.data;
+    }
+  }
+
+  return out;
+}
 
 // ---------------------------------------------------------------------------
 // Handlers
@@ -42,10 +114,18 @@ const providerConnectionResponseSchema = ProviderConnectionSchema;
 
 function handleListConnections({ queryParams = {} }: RouteHandlerArgs) {
   const provider = queryParams.provider;
+  if (provider) rejectDisabledOpenAICompatibleProvider(provider);
   const connections = listConnections(
     getDb(),
     provider ? { provider } : undefined,
   );
+  if (!openAICompatibleEndpointsEnabled()) {
+    return {
+      connections: connections.filter(
+        (conn) => conn.provider !== "openai-compatible",
+      ),
+    };
+  }
   return { connections };
 }
 
@@ -55,6 +135,12 @@ function handleGetConnection({ pathParams = {} }: RouteHandlerArgs) {
 
   const conn = getConnection(getDb(), name);
   if (!conn) throw new NotFoundError(`Connection "${name}" not found.`);
+  if (
+    conn.provider === "openai-compatible" &&
+    !openAICompatibleEndpointsEnabled()
+  ) {
+    throw new NotFoundError(`Connection "${name}" not found.`);
+  }
 
   return conn;
 }
@@ -74,6 +160,7 @@ function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
       `Invalid provider "${String(provider)}". Valid: ${VALID_CONNECTION_PROVIDERS.join(", ")}`,
     );
   }
+  rejectDisabledOpenAICompatibleProvider(providerResult.data);
 
   const authResult = AuthSchema.safeParse(auth);
   if (!authResult.success) {
@@ -99,12 +186,15 @@ function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
     );
   }
 
+  const customFields = parseCustomProviderFields(body);
+
   const result = createConnection(getDb(), {
     name,
     provider: providerResult.data,
     auth: authResult.data,
     ...(statusResult ? { status: statusResult.data } : {}),
     ...(labelRaw !== undefined ? { label: labelRaw as string | null } : {}),
+    ...customFields,
   });
 
   if (!result.ok) {
@@ -118,6 +208,16 @@ function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
         `Invalid provider "${result.error.provider}". Valid: ${VALID_CONNECTION_PROVIDERS.join(", ")}`,
       );
     }
+    if (result.error.code === "base_url_required") {
+      throw new BadRequestError(
+        "base_url is required for openai-compatible connections.",
+      );
+    }
+    if (result.error.code === "models_required") {
+      throw new BadRequestError(
+        "At least one model is required for openai-compatible connections.",
+      );
+    }
     throw new BadRequestError("Invalid auth configuration.");
   }
 
@@ -131,6 +231,15 @@ function handleUpdateConnection({
   const { name } = pathParams;
   if (!name) throw new BadRequestError("name is required");
 
+  const existing = getConnection(getDb(), name);
+  if (!existing) throw new NotFoundError(`Connection "${name}" not found.`);
+  if (
+    existing.provider === "openai-compatible" &&
+    !openAICompatibleEndpointsEnabled()
+  ) {
+    throw new NotFoundError(`Connection "${name}" not found.`);
+  }
+
   const auth = body.auth;
   const authResult = AuthSchema.safeParse(auth);
   if (!authResult.success) {
@@ -169,16 +278,29 @@ function handleUpdateConnection({
     );
   }
 
+  const customFields = parseCustomProviderFields(body);
+
   const result = updateConnection(getDb(), name, {
     auth: authResult.data,
     ...(statusResult ? { status: statusResult.data } : {}),
     ...(labelRaw !== undefined ? { label: labelRaw as string | null } : {}),
+    ...customFields,
   });
 
   if (!result.ok) {
     if (result.error.code === "not_found") {
       throw new NotFoundError(`Connection "${name}" not found.`);
     }
+    if (result.error.code === "base_url_required") {
+      throw new BadRequestError(
+        "base_url is required for openai-compatible connections.",
+      );
+    }
+    if (result.error.code === "models_required") {
+      throw new BadRequestError(
+        "At least one model is required for openai-compatible connections.",
+      );
+    }
     throw new BadRequestError("Invalid auth configuration.");
   }
 
@@ -191,7 +313,14 @@ function handleDeleteConnection({ pathParams = {} }: RouteHandlerArgs) {
 
   // Existence check first so a stale `llm.default.provider_connection`
   // reference to a missing connection returns 404 (not 409).
-  if (!getConnection(getDb(), name)) {
+  const existing = getConnection(getDb(), name);
+  if (!existing) {
+    throw new NotFoundError(`Connection "${name}" not found.`);
+  }
+  if (
+    existing.provider === "openai-compatible" &&
+    !openAICompatibleEndpointsEnabled()
+  ) {
     throw new NotFoundError(`Connection "${name}" not found.`);
   }
 
@@ -301,6 +430,8 @@ export const ROUTES: RouteDefinition[] = [
       auth: AuthSchema,
       label: z.string().min(1).optional(),
       status: ConnectionStatusSchema.optional(),
+      base_url: z.string().url().nullable().optional(),
+      models: z.array(ConnectionModelSchema).nullable().optional(),
     }),
     responseBody: providerConnectionResponseSchema,
     responseStatus: "201",
@@ -324,6 +455,8 @@ export const ROUTES: RouteDefinition[] = [
       auth: AuthSchema,
       status: ConnectionStatusSchema.optional(),
       label: z.string().min(1).nullable().optional(),
+      base_url: z.string().url().nullable().optional(),
+      models: z.array(ConnectionModelSchema).nullable().optional(),
     }),
     responseBody: providerConnectionResponseSchema,
     additionalResponses: {