@vellumai/assistant 0.8.3 → 0.8.5

package/src/runtime/routes/inference-profile-session-handler.ts

@@ -67,11 +67,13 @@ export async function setInferenceProfileSession({
   profile,
   ttlSeconds,
   sessionId: callerSessionId,
+  originClientId,
 }: {
   conversationId: string;
   profile: string | null;
   ttlSeconds?: number | null;
   sessionId?: string;
+  originClientId?: string;
 }): Promise<InferenceProfileSessionResult> {
   const resolvedId = resolveConversationId(conversationId) ?? conversationId;
   const conversation = getConversation(resolvedId);
@@ -116,12 +118,15 @@ export async function setInferenceProfileSession({
       };
     }
     setConversationInferenceProfileSession(resolvedId, null, null, null);
-    publishConversationInferenceProfileChanged({
-      conversationId: resolvedId,
-      profile: null,
-      sessionId: null,
-      expiresAt: null,
-    });
+    publishConversationInferenceProfileChanged(
+      {
+        conversationId: resolvedId,
+        profile: null,
+        sessionId: null,
+        expiresAt: null,
+      },
+      originClientId,
+    );
     return {
       conversationId: resolvedId,
       profile: null,
@@ -184,12 +189,15 @@ export async function setInferenceProfileSession({
     newExpiresAt ?? null,
   );
 
-  publishConversationInferenceProfileChanged({
-    conversationId: resolvedId,
-    profile,
-    sessionId: newSessionId ?? null,
-    expiresAt: newExpiresAt ?? null,
-  });
+  publishConversationInferenceProfileChanged(
+    {
+      conversationId: resolvedId,
+      profile,
+      sessionId: newSessionId ?? null,
+      expiresAt: newExpiresAt ?? null,
+    },
+    originClientId,
+  );
 
   return {
     conversationId: resolvedId,
@@ -218,6 +226,7 @@ export async function setInferenceProfileSession({
  */
 export async function closeInferenceProfileSession(
   conversationId: string,
+  originClientId?: string,
 ): Promise<{
   conversationId: string;
   closed: { profile: string | null; sessionId: string | null } | null;
@@ -241,6 +250,7 @@ export async function closeInferenceProfileSession(
   const result = await setInferenceProfileSession({
     conversationId: resolvedId,
     profile: null,
+    originClientId,
   });
   return {
     conversationId: result.conversationId,

package/src/runtime/routes/inference-profile-session-routes.ts

@@ -22,6 +22,7 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 async function handleOpenInferenceProfileSession({
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   if (body.profile == null || typeof body.profile !== "string") {
     throw new BadRequestError("profile must be a non-empty string");
@@ -31,13 +32,18 @@ async function handleOpenInferenceProfileSession({
     profile: body.profile,
     ttlSeconds: body.ttlSeconds as number | null | undefined,
     sessionId: body.sessionId as string | undefined,
+    originClientId: headers?.["x-vellum-client-id"]?.trim() || undefined,
   });
 }
 
 async function handleCloseInferenceProfileSession({
   body = {},
+  headers,
 }: RouteHandlerArgs) {
-  return closeInferenceProfileSession(body.conversationId as string);
+  return closeInferenceProfileSession(
+    body.conversationId as string,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 }
 
 function handleListInferenceProfileSessions({

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

@@ -28,8 +28,14 @@ import {
   getConnection,
   listConnections,
   MANAGED_CONNECTION_NAMES,
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
   updateConnection,
 } from "../../providers/inference/connections.js";
+import {
+  isPrivateOrLocalHost,
+  resolveHostAddresses,
+  resolveRequestAddress,
+} from "../../tools/network/url-safety.js";
 import { BadRequestError, ConflictError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -59,10 +65,26 @@ function rejectDisabledOpenAICompatibleProvider(provider: string): void {
 // Custom provider field parsing (openai-compatible base_url + models)
 // ---------------------------------------------------------------------------
 
-function parseCustomProviderFields(body: Record<string, unknown>): {
+/**
+ * Parse and validate `base_url` and `models` from the request body.
+ *
+ * `base_url` is only accepted for providers in
+ * `PROVIDERS_REQUIRING_BASE_URL_AND_MODELS` (currently `openai-compatible`).
+ * For all other providers, supplying `base_url` returns a 400. This prevents
+ * API-key exfiltration: an attacker cannot create an `anthropic` connection
+ * with a `base_url` pointing to their own server, which would redirect all
+ * LLM calls (and the API key) to the attacker.
+ *
+ * Even for `openai-compatible`, the `base_url` must not point to private
+ * networks or cloud metadata endpoints (SSRF protection).
+ */
+async function parseCustomProviderFields(
+  body: Record<string, unknown>,
+  provider: string,
+): Promise<{
   baseUrl?: string | null;
   models?: ConnectionModel[] | null;
-} {
+}> {
   const out: {
     baseUrl?: string | null;
     models?: ConnectionModel[] | null;
@@ -70,11 +92,24 @@ function parseCustomProviderFields(body: Record<string, unknown>): {
 
   if ("base_url" in body) {
     const raw = body.base_url;
+
+    // Gate: base_url is only valid for openai-compatible providers.
+    if (
+      raw !== null &&
+      raw !== undefined &&
+      !PROVIDERS_REQUIRING_BASE_URL_AND_MODELS.has(provider)
+    ) {
+      throw new BadRequestError(
+        `base_url is only valid for openai-compatible providers. Remove base_url or use the openai-compatible provider type.`,
+      );
+    }
+
     if (raw === null) {
       out.baseUrl = null;
     } else if (typeof raw === "string" && raw.length > 0) {
+      let parsed: URL;
       try {
-        const parsed = new URL(raw);
+        parsed = new URL(raw);
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
           throw new BadRequestError(`Invalid base_url: must be an http(s) URL`);
         }
@@ -84,6 +119,27 @@ function parseCustomProviderFields(body: Record<string, unknown>): {
           `Invalid base_url: must be a valid http(s) URL`,
         );
       }
+
+      // SSRF protection: reject private IPs, localhost, cloud metadata endpoints.
+      const hostname = parsed.hostname;
+      if (isPrivateOrLocalHost(hostname)) {
+        throw new BadRequestError(
+          `Invalid base_url: must not point to a private or local network address.`,
+        );
+      }
+
+      // DNS resolution check: hostname may resolve to a private IP.
+      const resolved = await resolveRequestAddress(
+        hostname,
+        resolveHostAddresses,
+        /* allowPrivateNetwork */ false,
+      );
+      if (resolved.blockedAddress) {
+        throw new BadRequestError(
+          `Invalid base_url: hostname resolves to a private network address.`,
+        );
+      }
+
       out.baseUrl = raw;
     } else {
       throw new BadRequestError(
@@ -145,7 +201,7 @@ function handleGetConnection({ pathParams = {} }: RouteHandlerArgs) {
   return conn;
 }
 
-function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
+async function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
   const name = body.name;
   const provider = body.provider;
   const auth = body.auth;
@@ -186,7 +242,7 @@ function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
     );
   }
 
-  const customFields = parseCustomProviderFields(body);
+  const customFields = await parseCustomProviderFields(body, providerResult.data);
 
   const result = createConnection(getDb(), {
     name,
@@ -224,7 +280,7 @@ function handleCreateConnection({ body = {} }: RouteHandlerArgs) {
   return result.connection;
 }
 
-function handleUpdateConnection({
+async function handleUpdateConnection({
   pathParams = {},
   body = {},
 }: RouteHandlerArgs) {
@@ -278,7 +334,7 @@ function handleUpdateConnection({
     );
   }
 
-  const customFields = parseCustomProviderFields(body);
+  const customFields = await parseCustomProviderFields(body, existing.provider);
 
   const result = updateConnection(getDb(), name, {
     auth: authResult.data,

package/src/runtime/routes/integrations/a2a.ts

@@ -7,11 +7,13 @@
  * POST   /v1/integrations/a2a/invite          — create a shareable A2A invite token
  * POST   /v1/integrations/a2a/invite/complete — sender-side invite completion
  * POST   /v1/integrations/a2a/invite/redeem   — receiver-side invite redemption
+ * POST   /v1/integrations/a2a/invite/accept   — self-hosted broker: orchestrate complete + redeem
  */
 
 import { isA2AEnabled } from "../../../a2a/feature-gate.js";
 import { getConfig } from "../../../config/loader.js";
 import {
+  acceptA2AInvite,
   clearA2AConfig,
   completeA2AInvite,
   createA2AInvite,
@@ -19,7 +21,7 @@ import {
   redeemA2AInvite,
   setA2AConfig,
 } from "../../../daemon/handlers/config-a2a.js";
-import { BadRequestError } from "../errors.js";
+import { BadGatewayError, BadRequestError } from "../errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -164,6 +166,52 @@ function handleRedeemA2AInvite({ body = {} }: RouteHandlerArgs) {
   return result;
 }
 
+async function handleAcceptA2AInvite({ body = {} }: RouteHandlerArgs) {
+  assertA2AFlag();
+  const { senderGatewayUrl, senderAssistantId, token } = body as {
+    senderGatewayUrl?: unknown;
+    senderAssistantId?: unknown;
+    token?: unknown;
+  };
+
+  if (typeof senderGatewayUrl !== "string" || !senderGatewayUrl) {
+    throw new BadRequestError(
+      "senderGatewayUrl is required and must be a non-empty string",
+    );
+  }
+  try {
+    new URL(senderGatewayUrl);
+  } catch {
+    throw new BadRequestError("senderGatewayUrl must be a valid URL");
+  }
+  if (typeof senderAssistantId !== "string" || !senderAssistantId) {
+    throw new BadRequestError(
+      "senderAssistantId is required and must be a non-empty string",
+    );
+  }
+  if (typeof token !== "string" || !token) {
+    throw new BadRequestError(
+      "token is required and must be a non-empty string",
+    );
+  }
+
+  const result = await acceptA2AInvite({
+    senderGatewayUrl,
+    senderAssistantId,
+    token,
+  });
+  if (!result.success) {
+    const isSenderFault =
+      result.errorCode === "sender_unreachable" ||
+      result.errorCode === "complete_failed";
+    if (isSenderFault) {
+      throw new BadGatewayError(result.error ?? "Failed to accept A2A invite");
+    }
+    throw new BadRequestError(result.error ?? "Failed to accept A2A invite");
+  }
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -232,4 +280,15 @@ export const ROUTES: RouteDefinition[] = [
     requirePolicyEnforcement: true,
     handler: handleRedeemA2AInvite,
   },
+  {
+    operationId: "integrations_a2a_invite_accept_post",
+    endpoint: "integrations/a2a/invite/accept",
+    method: "POST",
+    summary: "Accept A2A invite (self-hosted broker)",
+    description:
+      "Orchestrate cross-daemon invite acceptance for self-hosted deployments. Calls the sender's invite/complete, then creates a local contact via invite/redeem.",
+    tags: ["integrations"],
+    requirePolicyEnforcement: true,
+    handler: handleAcceptA2AInvite,
+  },
 ];

package/src/runtime/routes/llm-call-sites-routes.ts

@@ -1,6 +1,9 @@
 import { resolveDefaultProfileKey } from "../../config/llm-resolver.js";
 import { loadConfig } from "../../config/loader.js";
-import { CALL_SITE_CATALOG, CALL_SITE_DOMAINS } from "../../config/schemas/call-site-catalog.js";
+import {
+  CALL_SITE_CATALOG,
+  CALL_SITE_DOMAINS,
+} from "../../config/schemas/call-site-catalog.js";
 import type { LLMCallSite } from "../../config/schemas/llm.js";
 import type { RouteDefinition } from "./types.js";
 
@@ -10,14 +13,28 @@ async function handleGetCallSites() {
     domains: CALL_SITE_DOMAINS,
     callSites: CALL_SITE_CATALOG.map((entry) => ({
       ...entry,
-      defaultProfile: resolveDefaultProfileKey(
-        entry.id as LLMCallSite,
-        llm,
-      ),
+      defaultProfile: resolveDefaultProfileKey(entry.id as LLMCallSite, llm),
     })),
   };
 }
 
+export interface LlmProfilesListResult {
+  /** Sorted list of profile names defined in `llm.profiles`. */
+  profiles: string[];
+  /** The workspace-wide active profile name, if one is set. */
+  activeProfile: string | null;
+}
+
+async function handleListProfiles(): Promise<LlmProfilesListResult> {
+  const { llm } = loadConfig();
+  const profiles = llm?.profiles ?? {};
+  return {
+    profiles: Object.keys(profiles).sort(),
+    activeProfile:
+      typeof llm?.activeProfile === "string" ? llm.activeProfile : null,
+  };
+}
+
 export const ROUTES: RouteDefinition[] = [
   {
     operationId: "llm_call_sites_list",
@@ -29,4 +46,14 @@ export const ROUTES: RouteDefinition[] = [
       "Returns the full catalog of LLM call sites with display names, descriptions, and domain groupings. Used by clients to render the per-call-site override settings UI.",
     tags: ["config"],
   },
+  {
+    operationId: "llm_profiles_list",
+    method: "GET",
+    endpoint: "config/llm/profiles",
+    handler: handleListProfiles,
+    summary: "List defined LLM profiles",
+    description:
+      "Returns the sorted list of profile names defined in `llm.profiles` plus the workspace-wide active profile. Used to populate per-call profile dropdowns (e.g. memory router playground) without requiring the caller to type profile names.",
+    tags: ["config"],
+  },
 ];

package/src/runtime/routes/log-export-routes.ts

@@ -36,6 +36,7 @@ import {
   getWorkspaceConfigPath,
 } from "../../util/platform.js";
 import { APP_VERSION, COMMIT_SHA } from "../../version.js";
+import { assistantEventHub } from "../assistant-event-hub.js";
 import { createTarGz } from "./archive-utils.js";
 import { InternalError } from "./errors.js";
 import { collectWorkspaceData } from "./log-export/workspace-allowlist.js";
@@ -270,6 +271,44 @@ async function handleExport({
       );
     }
 
+    // --- Connected clients (`assistant clients list --json`) ---
+    try {
+      const clients = assistantEventHub.listClients();
+      const clientsList = {
+        clients: clients.map((c) => ({
+          clientId: c.clientId,
+          interfaceId: c.interfaceId,
+          capabilities: c.capabilities,
+          machineName: c.machineName,
+          connectedAt: c.connectedAt.toISOString(),
+          lastActiveAt: c.lastActiveAt.toISOString(),
+        })),
+      };
+      writeFileSync(
+        join(staging, "clients-list.json"),
+        JSON.stringify(clientsList, null, 2),
+        "utf-8",
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      writeFileSync(
+        join(staging, "clients-list-error.json"),
+        JSON.stringify(
+          {
+            error: message,
+            collectedAt: new Date().toISOString(),
+          },
+          null,
+          2,
+        ),
+        "utf-8",
+      );
+      log.warn(
+        { err },
+        "Failed to collect connected clients list, continuing without it",
+      );
+    }
+
     // --- Export manifest ---
     const manifestType = conversationId
       ? ("conversation-export" as const)

package/src/runtime/routes/memory-item-routes.ts

@@ -44,7 +44,10 @@ import type {
   MemoryType,
   NewNode,
 } from "../../memory/graph/types.js";
-import { enqueueMemoryJob } from "../../memory/jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+} from "../../memory/jobs-store.js";
 import { withQdrantBreaker } from "../../memory/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../../memory/qdrant-client.js";
 import { memoryGraphNodes } from "../../memory/schema.js";
@@ -525,7 +528,9 @@ async function handleCreateMemoryItem(body: Record<string, unknown>) {
   };
 
   const created = createNode(newNode);
-  enqueueMemoryJob("embed_graph_node", { nodeId: created.id });
+  if (isMemoryEnabled()) {
+    enqueueMemoryJob("embed_graph_node", { nodeId: created.id });
+  }
 
   return { item: nodeToPayload(created) };
 }
@@ -619,7 +624,7 @@ async function handleUpdateMemoryItem(
 
   updateNode(id, changes);
 
-  if (contentChanged) {
+  if (contentChanged && isMemoryEnabled()) {
     enqueueMemoryJob("embed_graph_node", { nodeId: id });
   }