@vellumai/assistant 0.8.1 → 0.8.3

package/src/daemon/handlers/config-a2a.ts

@@ -0,0 +1,289 @@
+/**
+ * A2A channel configuration handler.
+ *
+ * - getA2AConfig()     — read a2a.enabled, count active a2a contact_channels
+ * - setA2AConfig()     — set a2a.enabled = true
+ * - clearA2AConfig()   — set a2a.enabled = false
+ * - createA2AInvite()  — create a shareable invite token for link-based contact creation
+ * - redeemA2AInvite()  — receiver-side: create trusted contact from sender identity
+ */
+
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
+import {
+  findContactByAddress,
+  searchContacts,
+  upsertContact,
+} from "../../contacts/contact-store.js";
+import type { VellumAssistantMetadata } from "../../contacts/types.js";
+import { getPublicBaseUrl } from "../../inbound/public-ingress-urls.js";
+import { getDb } from "../../memory/db-connection.js";
+import {
+  claimA2AInvite,
+  createInvite,
+  hashToken,
+} from "../../memory/invite-store.js";
+import { assistantContactMetadata } from "../../memory/schema.js";
+import { getAssistantName } from "../identity-helpers.js";
+// ── Result types ────────────────────────────────────────────────────
+
+export interface A2AConfigResult {
+  success: boolean;
+  enabled: boolean;
+  activeConnections: number;
+  error?: string;
+}
+
+export interface CreateA2AInviteResult {
+  success: boolean;
+  inviteId?: string;
+  token?: string;
+  expiresAt?: number;
+  senderGatewayUrl?: string;
+  error?: string;
+}
+
+export interface CompleteA2AInviteResult {
+  success: boolean;
+  sender?: { assistantId: string; displayName: string; gatewayUrl: string };
+  error?: string;
+}
+
+export interface RedeemA2AInviteResult {
+  success: boolean;
+  contactId?: string;
+  alreadyConnected?: boolean;
+  error?: string;
+}
+
+// ── Config operations ───────────────────────────────────────────────
+
+export function getA2AConfig(): A2AConfigResult {
+  const config = getConfig();
+  const enabled = config.a2a?.enabled ?? false;
+
+  const contacts = searchContacts({ channelType: "a2a" });
+  const activeConnections = contacts.reduce((count, c) => {
+    return (
+      count +
+      c.channels.filter((ch) => ch.type === "a2a" && ch.status === "active")
+        .length
+    );
+  }, 0);
+
+  return { success: true, enabled, activeConnections };
+}
+
+export function setA2AConfig(): A2AConfigResult {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "a2a.enabled", true);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  const result = getA2AConfig();
+  return { ...result, success: true };
+}
+
+export function clearA2AConfig(): A2AConfigResult {
+  const raw = loadRawConfig();
+  setNestedValue(raw, "a2a.enabled", false);
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  return { success: true, enabled: false, activeConnections: 0 };
+}
+
+// ── A2A invite creation ────────────────────────────────────────────
+
+export function createA2AInvite(params: {
+  expiresInHours?: number;
+}): CreateA2AInviteResult {
+  // 1. Ensure A2A channel is enabled (auto-enable on first invite)
+  const config = getA2AConfig();
+  if (!config.enabled) {
+    setA2AConfig();
+  }
+
+  // 2. Resolve public base URL
+  let publicBaseUrl: string;
+  try {
+    publicBaseUrl = getPublicBaseUrl(getConfig());
+  } catch {
+    return {
+      success: false,
+      error:
+        "No public base URL configured. Set ingress.publicBaseUrl in config.",
+    };
+  }
+
+  // 3. Create placeholder contact (no channels — will be bound on acceptance)
+  const contact = upsertContact({
+    displayName: "Pending A2A invite",
+    contactType: "assistant",
+    role: "contact",
+  });
+
+  // 4. Create the invite
+  const expiresInMs = (params.expiresInHours ?? 72) * 60 * 60 * 1000;
+  const { invite, rawToken } = createInvite({
+    sourceChannel: "a2a",
+    contactId: contact.id,
+    maxUses: 1,
+    expiresInMs,
+  });
+
+  return {
+    success: true,
+    inviteId: invite.id,
+    token: rawToken,
+    expiresAt: invite.expiresAt,
+    senderGatewayUrl: publicBaseUrl,
+  };
+}
+
+// ── A2A invite completion (sender side) ───────────────────────────
+
+export function completeA2AInvite(params: {
+  token: string;
+  senderAssistantId: string;
+  acceptor: {
+    assistantId: string;
+    displayName: string;
+    gatewayUrl: string;
+  };
+}): CompleteA2AInviteResult {
+  // Resolve sender identity before any mutations so we fail cleanly
+  const displayName = getAssistantName() ?? "Vellum Assistant";
+  let gatewayUrl: string;
+  try {
+    gatewayUrl = getPublicBaseUrl(getConfig());
+  } catch {
+    return {
+      success: false,
+      error:
+        "No public base URL configured. Set ingress.publicBaseUrl in config.",
+    };
+  }
+
+  const tokenHash = hashToken(params.token);
+  const claimResult = claimA2AInvite({
+    tokenHash,
+    redeemedByExternalUserId: params.acceptor.assistantId,
+  });
+
+  if (!claimResult.claimed || !claimResult.invite) {
+    return { success: false, error: claimResult.error };
+  }
+
+  const invite = claimResult.invite;
+
+  // Promote the placeholder contact with the acceptor's identity
+  upsertContact({
+    id: invite.contactId,
+    displayName: params.acceptor.displayName,
+    contactType: "assistant",
+    role: "contact",
+    channels: [
+      {
+        type: "a2a",
+        address: params.acceptor.assistantId.toLowerCase(),
+        externalUserId: params.acceptor.assistantId,
+        status: "active",
+        policy: "allow",
+      },
+    ],
+  });
+
+  // Write assistant contact metadata
+  const db = getDb();
+  const metadataJson = JSON.stringify({
+    assistantId: params.acceptor.assistantId,
+    gatewayUrl: params.acceptor.gatewayUrl,
+  } satisfies VellumAssistantMetadata);
+  db.insert(assistantContactMetadata)
+    .values({
+      contactId: invite.contactId,
+      species: "vellum",
+      metadata: metadataJson,
+    })
+    .onConflictDoUpdate({
+      target: assistantContactMetadata.contactId,
+      set: { species: "vellum", metadata: metadataJson },
+    })
+    .run();
+
+  return {
+    success: true,
+    sender: {
+      assistantId: params.senderAssistantId,
+      displayName,
+      gatewayUrl,
+    },
+  };
+}
+
+// ── A2A invite redemption (receiver side) ─────────────────────────
+
+export function redeemA2AInvite(params: {
+  sender: {
+    assistantId: string;
+    displayName: string;
+    gatewayUrl: string;
+  };
+}): RedeemA2AInviteResult {
+  // 1. Ensure A2A channel is enabled (auto-enable if needed)
+  const config = getA2AConfig();
+  if (!config.enabled) {
+    setA2AConfig();
+  }
+
+  // 2. Check for existing active contact with this sender
+  const existing = findContactByAddress("a2a", params.sender.assistantId);
+  if (
+    existing &&
+    existing.channels.some((ch) => ch.type === "a2a" && ch.status === "active")
+  ) {
+    return { success: true, alreadyConnected: true, contactId: existing.id };
+  }
+
+  // 3. Create the sender as a local trusted contact
+  const contact = upsertContact({
+    displayName: params.sender.displayName,
+    contactType: "assistant",
+    role: "contact",
+    channels: [
+      {
+        type: "a2a",
+        address: params.sender.assistantId.toLowerCase(),
+        externalUserId: params.sender.assistantId,
+        status: "active",
+        policy: "allow",
+      },
+    ],
+  });
+
+  // 4. Write assistant contact metadata
+  const db = getDb();
+  const metadataJson = JSON.stringify({
+    assistantId: params.sender.assistantId,
+    gatewayUrl: params.sender.gatewayUrl,
+  } satisfies VellumAssistantMetadata);
+  db.insert(assistantContactMetadata)
+    .values({
+      contactId: contact.id,
+      species: "vellum",
+      metadata: metadataJson,
+    })
+    .onConflictDoUpdate({
+      target: assistantContactMetadata.contactId,
+      set: { species: "vellum", metadata: metadataJson },
+    })
+    .run();
+
+  return { success: true, contactId: contact.id };
+}

package/src/daemon/handlers/config-model.ts

@@ -7,8 +7,8 @@ import {
 import { setServiceField } from "../../config/raw-config-utils.js";
 import { providerForImageModelPrefix } from "../../media/types.js";
 import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
-import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
 import { getConfiguredProviders } from "../../providers/provider-availability.js";
+import { getVisibleProviderCatalog } from "../../providers/provider-catalog-visibility.js";
 import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
 
 // ---------------------------------------------------------------------------
@@ -65,15 +65,16 @@ export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
   const resolved = resolveCallSiteConfig("mainAgent", config.llm);
   const provider = resolved.provider;
+  const visibleCatalog = getVisibleProviderCatalog(config);
 
   return {
     model: resolved.model,
     provider,
     configuredProviders: await getConfiguredProviders(),
-    availableModels: PROVIDER_CATALOG.find(
-      (p) => p.id === provider,
-    )?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
-    allProviders: PROVIDER_CATALOG.map(projectProviderForWire),
+    availableModels: visibleCatalog
+      .find((p) => p.id === provider)
+      ?.models?.map((m) => ({ id: m.id, displayName: m.displayName })),
+    allProviders: visibleCatalog.map(projectProviderForWire),
   };
 }
 

package/src/daemon/handlers/config-slack-channel.ts

@@ -34,6 +34,7 @@ export interface SlackChannelConfigResult {
   connected: boolean;
   teamId?: string;
   teamName?: string;
+  teamUrl?: string;
   botUserId?: string;
   botUsername?: string;
   error?: string;
@@ -93,7 +94,8 @@ export function backfillSlackInjectionTemplates(): void {
 // -- Business logic --
 
 export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult> {
-  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+  const { teamId, teamName, teamUrl, botUserId, botUsername } =
+    getConfig().slack;
   const accountInfo = teamName
     ? `${teamName}${botUsername ? ` (@${botUsername})` : ""}`
     : undefined;
@@ -129,6 +131,7 @@ export async function getSlackChannelConfig(): Promise<SlackChannelConfigResult>
     connected,
     ...(teamId ? { teamId } : {}),
     ...(teamName ? { teamName } : {}),
+    ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
   };
@@ -169,6 +172,7 @@ export async function setSlackChannelConfig(
   let metadata: {
     teamId?: string;
     teamName?: string;
+    teamUrl?: string;
     botUserId?: string;
     botUsername?: string;
   } = {};
@@ -187,6 +191,7 @@ export async function setSlackChannelConfig(
         error?: string;
         team_id?: string;
         team?: string;
+        url?: string;
         user_id?: string;
         user?: string;
       };
@@ -198,6 +203,7 @@ export async function setSlackChannelConfig(
       metadata = {
         teamId: data.team_id,
         teamName: data.team,
+        teamUrl: data.url,
         botUserId: data.user_id,
         botUsername: data.user,
       };
@@ -221,6 +227,7 @@ export async function setSlackChannelConfig(
     const raw = loadRawConfig();
     setNestedValue(raw, "slack.teamId", metadata.teamId ?? "");
     setNestedValue(raw, "slack.teamName", metadata.teamName ?? "");
+    setNestedValue(raw, "slack.teamUrl", metadata.teamUrl ?? "");
     setNestedValue(raw, "slack.botUserId", metadata.botUserId ?? "");
     setNestedValue(raw, "slack.botUsername", metadata.botUsername ?? "");
     saveRawConfig(raw);
@@ -293,10 +300,12 @@ export async function setSlackChannelConfig(
     }
   } else {
     // Use existing metadata from config if no new bot token provided
-    const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+    const { teamId, teamName, teamUrl, botUserId, botUsername } =
+      getConfig().slack;
     metadata = {
       ...(teamId ? { teamId } : {}),
       ...(teamName ? { teamName } : {}),
+      ...(teamUrl ? { teamUrl } : {}),
       ...(botUserId ? { botUserId } : {}),
       ...(botUsername ? { botUsername } : {}),
     };
@@ -468,7 +477,8 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
     credentialKey("slack_channel", "app_token"),
   ));
   const conn = getConnectionByProvider("slack_channel");
-  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+  const { teamId, teamName, teamUrl, botUserId, botUsername } =
+    getConfig().slack;
 
   return {
     success: true,
@@ -479,6 +489,7 @@ export async function clearSlackUserToken(): Promise<SlackChannelConfigResult> {
       !!(conn && conn.status === "active") && hasBotToken && hasAppToken,
     ...(teamId ? { teamId } : {}),
     ...(teamName ? { teamName } : {}),
+    ...(teamUrl ? { teamUrl } : {}),
     ...(botUserId ? { botUserId } : {}),
     ...(botUsername ? { botUsername } : {}),
   };
@@ -528,6 +539,7 @@ export async function clearSlackChannelConfig(): Promise<SlackChannelConfigResul
   const raw = loadRawConfig();
   setNestedValue(raw, "slack.teamId", "");
   setNestedValue(raw, "slack.teamName", "");
+  setNestedValue(raw, "slack.teamUrl", "");
   setNestedValue(raw, "slack.botUserId", "");
   setNestedValue(raw, "slack.botUsername", "");
   saveRawConfig(raw);

package/src/daemon/handlers/conversations.ts

@@ -141,6 +141,7 @@ export async function regenerateResponse(
   const conversation = await getOrCreateConversation(conversationId);
   touchConversation(conversationId);
   conversation.updateClient(broadcastMessage, false);
+  getSubagentManager().updateParentSender(conversationId, broadcastMessage);
   const requestId = uuid();
   conversation.traceEmitter.emit("request_received", "Regenerate requested", {
     requestId,

package/src/daemon/handlers/shared.ts

@@ -6,6 +6,7 @@ import type { SecretPromptResult } from "../../permissions/secret-prompter.js";
 import { isPlaceholderSentinelText } from "../../providers/anthropic/client.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../../runtime/auth/types.js";
+import { unwrapExternalContentForDisplay } from "../../security/untrusted-content.js";
 import { getLogger } from "../../util/logger.js";
 import { estimateBase64Bytes } from "../assistant-attachments.js";
 import type { ConversationTransportMetadata } from "../message-protocol.js";
@@ -120,6 +121,8 @@ export interface SlackInboundMessageMetadata {
   threadTs?: string;
   /** Resolved sender label (display name preferred, username fallback). */
   displayName?: string;
+  /** Canonical Slack external user id for the sender, when available. */
+  actorExternalUserId?: string;
 }
 
 /**
@@ -143,6 +146,11 @@ export interface ConversationCreateOptions {
   isInteractive?: boolean;
   /** Slack-only non-persisted notice injected into the active model turn. */
   slackRuntimeContextNotice?: string;
+  /**
+   * Persisted user-facing content. When present, storage/UI use this value
+   * while the model-facing turn continues to use `content`.
+   */
+  displayContent?: string;
   /** Channel command intent metadata (e.g. Telegram /start). */
   commandIntent?: { type: string; payload?: string; languageCode?: string };
 
@@ -219,7 +227,7 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
     } else if (typeof content === "object") {
       text = JSON.stringify(content);
     } else {
-      text = String(content);
+      text = unwrapExternalContentForDisplay(String(content));
     }
     return {
       text,
@@ -324,20 +332,21 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
     }
 
     if (block.type === "text" && typeof block.text === "string") {
+      const displayText = unwrapExternalContentForDisplay(block.text);
       // Skip empty/whitespace-only text blocks. During streaming the client
       // discards empty text deltas (guard !text.isEmpty), so including them
       // here produces a contentOrder that differs from the live streaming
       // path — e.g. empty segments between consecutive tool_use blocks that
       // break tool-call grouping in the UI.
-      if (block.text.trim().length === 0) continue;
+      if (displayText.trim().length === 0) continue;
       // Drop Anthropic provider placeholder sentinels. These are injected
       // into outbound API requests to preserve role alternation and must
       // never be rendered to users. Belt-and-suspenders with the persist-
       // time filter in cleanAssistantContent and migration 222.
-      if (isPlaceholderSentinelText(block.text)) continue;
-      textParts.push(block.text);
+      if (isPlaceholderSentinelText(displayText)) continue;
+      textParts.push(displayText);
       ensureSegment();
-      currentSegmentParts.push(block.text);
+      currentSegmentParts.push(displayText);
       seenText = true;
       continue;
     }