@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -0,0 +1,449 @@
+/**
+ * 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
+ * - completeA2AInvite() — sender-side: claim token and return sender identity
+ * - redeemA2AInvite()  — receiver-side: create trusted contact from sender identity
+ * - acceptA2AInvite()  — self-hosted broker: orchestrate complete + redeem across daemons
+ */
+
+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 type { HttpErrorResponse } from "../../runtime/http-errors.js";
+import { getLogger } from "../../util/logger.js";
+import { getAssistantName } from "../identity-helpers.js";
+const log = getLogger("config-a2a");
+
+// ── 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;
+}
+
+export interface AcceptA2AInviteResult {
+  success: boolean;
+  contactId?: string;
+  alreadyConnected?: boolean;
+  error?: string;
+  errorCode?: 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 };
+}
+
+// ── Self-hosted broker ──────────────────────────────────────────────
+
+const ACCEPT_TIMEOUT_MS = 15_000;
+
+/**
+ * Extract a human-readable error message from a daemon HTTP error
+ * response. The daemon always returns `{ error: { code, message } }`
+ * (see `HttpErrorResponse` in `runtime/http-errors.ts`).
+ */
+function extractDaemonErrorMessage(
+  body: Record<string, unknown>,
+): string | undefined {
+  const envelope = body as Partial<HttpErrorResponse>;
+  if (
+    typeof envelope.error === "object" &&
+    envelope.error !== null &&
+    typeof envelope.error.message === "string"
+  ) {
+    return envelope.error.message;
+  }
+  return undefined;
+}
+
+/**
+ * Orchestrate cross-daemon A2A invite acceptance for self-hosted
+ * deployments. Calls the sender's `invite/complete` endpoint, then
+ * creates a local contact via `redeemA2AInvite`.
+ *
+ * Trust model: the user explicitly chose to connect to `senderGatewayUrl`
+ * and provided a token from the sender's invite link. We trust the
+ * invite-link values (`senderAssistantId`, `senderGatewayUrl`) as the
+ * canonical sender identity, and only use the `complete` response for the
+ * sender's display name (which has no other source in self-hosted mode).
+ */
+export async function acceptA2AInvite(params: {
+  senderGatewayUrl: string;
+  senderAssistantId: string;
+  token: string;
+}): Promise<AcceptA2AInviteResult> {
+  const senderGatewayUrl = params.senderGatewayUrl.replace(/\/+$/, "");
+
+  // 1. Validate local config
+  const displayName = getAssistantName() ?? "Vellum Assistant";
+  let localGatewayUrl: string;
+  try {
+    localGatewayUrl = getPublicBaseUrl(getConfig());
+  } catch {
+    return {
+      success: false,
+      error:
+        "No public base URL configured. Set ingress.publicBaseUrl in config.",
+      errorCode: "no_public_url",
+    };
+  }
+
+  // 2. Short-circuit if already connected — avoids a network round-trip
+  //    and consuming a token on the sender side.
+  const existing = findContactByAddress("a2a", params.senderAssistantId);
+  if (
+    existing &&
+    existing.channels.some((ch) => ch.type === "a2a" && ch.status === "active")
+  ) {
+    return { success: true, alreadyConnected: true, contactId: existing.id };
+  }
+
+  // 3. Call the sender's invite/complete endpoint
+  const completeUrl = `${senderGatewayUrl}/v1/integrations/a2a/invite/complete`;
+  const completeBody = {
+    token: params.token,
+    senderAssistantId: params.senderAssistantId,
+    acceptor: {
+      assistantId: localGatewayUrl,
+      displayName,
+      gatewayUrl: localGatewayUrl,
+    },
+  };
+
+  let completeData: Record<string, unknown>;
+  try {
+    const response = await fetch(completeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(completeBody),
+      signal: AbortSignal.timeout(ACCEPT_TIMEOUT_MS),
+    });
+
+    completeData = (await response.json()) as Record<string, unknown>;
+
+    if (!response.ok) {
+      const error =
+        extractDaemonErrorMessage(completeData) ?? "Invite completion failed";
+      log.warn(
+        { senderGatewayUrl, status: response.status, error },
+        "Sender invite/complete returned error",
+      );
+      return { success: false, error, errorCode: "complete_failed" };
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn(
+      { senderGatewayUrl, error: message },
+      "Failed to reach sender for invite/complete",
+    );
+    return {
+      success: false,
+      error: `Failed to reach sender: ${message}`,
+      errorCode: "sender_unreachable",
+    };
+  }
+
+  // 4. Extract sender display name from the complete response; use
+  //    invite-link values for assistantId and gatewayUrl (trusted source).
+  const senderFromResponse = completeData.sender as
+    | { displayName?: string }
+    | undefined;
+
+  const senderIdentity = {
+    assistantId: params.senderAssistantId,
+    displayName:
+      (typeof senderFromResponse?.displayName === "string" &&
+        senderFromResponse.displayName) ||
+      params.senderAssistantId,
+    gatewayUrl: senderGatewayUrl,
+  };
+
+  // 5. Create the sender as a local trusted contact
+  const redeemResult = redeemA2AInvite({ sender: senderIdentity });
+  if (!redeemResult.success) {
+    log.warn(
+      { error: redeemResult.error },
+      "Local invite/redeem failed after successful complete",
+    );
+    return {
+      success: false,
+      error: redeemResult.error ?? "Failed to create sender contact",
+      errorCode: "redeem_failed",
+    };
+  }
+
+  return {
+    success: true,
+    contactId: redeemResult.contactId,
+    alreadyConnected: redeemResult.alreadyConnected,
+  };
+}

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

@@ -65,6 +65,7 @@ describe("projectProviderForWire", () => {
     const wire = projectProviderForWire(gemini!);
     const modelIds = wire.models.map((model) => model.id);
     const expectedGemini3ModelIds = [
+      "gemini-3.5-flash",
       "gemini-3.1-pro-preview",
       "gemini-3.1-pro-preview-customtools",
       "gemini-3-flash-preview",

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,
@@ -201,6 +202,85 @@ export function deleteQueuedMessage(
   return { removed: false, reason: "message_not_found" };
 }
 
+/**
+ * Steer a conversation to a specific queued message.
+ * Promotes the message to the head of the queue, marks the conversation
+ * as needing tool-result repair, and aborts the current generation so the
+ * drain path picks up the promoted message.
+ *
+ * Returns `{ steered: true }` on success, or `{ steered: false, reason }` on failure.
+ */
+export function steerToMessage(
+  conversationId: string,
+  requestId: string,
+):
+  | { steered: true }
+  | {
+      steered: false;
+      reason:
+        | "conversation_not_found"
+        | "message_not_found"
+        | "not_processing";
+    } {
+  const conversation = findConversation(conversationId);
+  if (!conversation) {
+    log.warn(
+      { conversationId, requestId },
+      "No conversation found for steer_to_message",
+    );
+    return { steered: false, reason: "conversation_not_found" };
+  }
+
+  if (!conversation.isProcessing()) {
+    log.warn(
+      { conversationId, requestId },
+      "Cannot steer: conversation is not processing",
+    );
+    return { steered: false, reason: "not_processing" };
+  }
+
+  const promoted = conversation.queue.promoteToHead(requestId);
+  if (!promoted) {
+    log.warn(
+      { conversationId, requestId },
+      "Queued message not found for steering",
+    );
+    return { steered: false, reason: "message_not_found" };
+  }
+
+  // Mark the conversation for tool-result repair so the drain path can
+  // inject synthetic tool results for any pending tool_use blocks that
+  // were abandoned by the aborted generation.
+  conversation.pendingSteerRepair = true;
+
+  // Broadcast the steer event so clients can update their UI.
+  broadcastMessage({
+    type: "message_steered",
+    conversationId,
+    requestId,
+  });
+
+  log.info(
+    { conversationId, requestId },
+    "Steering to queued message — aborting current generation",
+  );
+
+  // Abort the in-flight generation. The agent loop's finally block calls
+  // drainQueue, which will pick up the promoted message at the head.
+  // Unlike abortConversation, we do NOT clear the queue or dispose
+  // prompters — we want the queue to drain with the promoted message first.
+  const reason = createAbortReason(
+    "preempted_by_new_message",
+    "steerToMessage",
+    conversationId,
+  );
+  conversation.abortController?.abort(reason);
+  // Deny pending confirmations so the abort unblocks immediately.
+  conversation.denyAllPendingConfirmations();
+
+  return { steered: true };
+}
+
 // ---------------------------------------------------------------------------
 // HTTP handler (delegates to shared logic)
 // ---------------------------------------------------------------------------