@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -1,31 +1,18 @@
-import {
-  getTwilioCredentials,
-  hasTwilioCredentials,
-  updatePhoneNumberWebhooks,
-} from "../../calls/twilio-rest.js";
+import { updatePhoneNumberWebhooks } from "../../calls/twilio-rest.js";
 import {
   getGatewayInternalBaseUrl,
   getPlatformAssistantId,
   getPlatformBaseUrl,
-  setIngressPublicBaseUrl,
 } from "../../config/env.js";
 import { getIsPlatform } from "../../config/env-registry.js";
-import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
-import {
-  registerCallbackRoute,
-  resolveCallbackUrl,
-} from "../../inbound/platform-callback-registration.js";
+import { loadRawConfig } from "../../config/loader.js";
+import { resolveCallbackUrl } from "../../inbound/platform-callback-registration.js";
 import {
   getTwilioStatusCallbackUrl,
   getTwilioVoiceWebhookUrl,
   type IngressConfig,
 } from "../../inbound/public-ingress-urls.js";
-import type { IngressConfigRequest } from "../message-protocol.js";
-import {
-  CONFIG_RELOAD_DEBOUNCE_MS,
-  type HandlerContext,
-  log,
-} from "./shared.js";
+import { log } from "./shared.js";
 
 export function computeGatewayTarget(): string {
   return getGatewayInternalBaseUrl();
@@ -117,151 +104,3 @@ export async function syncTwilioWebhooks(
     };
   }
 }
-
-export async function handleIngressConfig(
-  msg: IngressConfigRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  const localGatewayTarget = computeGatewayTarget();
-  try {
-    if (msg.action === "get") {
-      const result = getIngressConfigResult();
-      ctx.send({
-        type: "ingress_config_response",
-        ...result,
-      });
-    } else if (msg.action === "set") {
-      const value = (msg.publicBaseUrl ?? "").trim().replace(/\/+$/, "");
-      const raw = loadRawConfig();
-
-      // Update ingress.publicBaseUrl — this is the single source of truth for
-      // the canonical public ingress URL. The gateway reads this value from
-      // the workspace config file via ConfigFileCache.
-      // The gateway also validates Twilio signatures against forwarded public
-      // URL headers, so local tunnel updates generally apply without restarts.
-      const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
-      ingress.publicBaseUrl = value || undefined;
-      if (msg.enabled !== undefined) {
-        ingress.enabled = msg.enabled;
-      }
-
-      const wasSuppressed = ctx.suppressConfigReload;
-      ctx.setSuppressConfigReload(true);
-      try {
-        saveRawConfig({ ...raw, ingress });
-      } catch (err) {
-        ctx.setSuppressConfigReload(wasSuppressed);
-        throw err;
-      }
-      ctx.debounceTimers.schedule(
-        "__suppress_reset__",
-        () => {
-          ctx.setSuppressConfigReload(false);
-        },
-        CONFIG_RELOAD_DEBOUNCE_MS,
-      );
-
-      // Propagate to module-level state so the assistant's in-process URL
-      // resolution stays in sync. The gateway reads from the workspace config
-      // file directly via ConfigFileCache, so no env var propagation is needed.
-      // Only set the URL when ingress is enabled; clearing it when
-      // disabled ensures the gateway stops accepting inbound webhooks.
-      const isEnabled = (ingress.enabled as boolean | undefined) ?? false;
-      if (value && isEnabled) {
-        setIngressPublicBaseUrl(value);
-      } else {
-        // Ingress is disabled or no URL is configured — clear the module-level
-        // URL so the gateway stops accepting webhooks.
-        setIngressPublicBaseUrl(undefined);
-      }
-
-      ctx.send({
-        type: "ingress_config_response",
-        enabled: isEnabled,
-        publicBaseUrl: value,
-        localGatewayTarget,
-        success: true,
-      });
-
-      // When containerized with a platform, register the Telegram callback
-      // route so the platform knows how to forward Telegram webhooks.
-      // This must happen independently of ingress URL — in containerized
-      // deployments without ingress.publicBaseUrl, platform callbacks are the
-      // only way to receive Telegram webhooks.
-      if (getIsPlatform()) {
-        registerCallbackRoute("webhooks/telegram", "telegram").catch((err) => {
-          log.warn(
-            { err },
-            "Failed to register Telegram platform callback route",
-          );
-        });
-      }
-
-      // Best-effort Twilio webhook reconciliation: when ingress is being
-      // enabled/updated and Twilio numbers are assigned with valid credentials,
-      // push the new webhook URLs to Twilio so calls route correctly.
-      if (isEnabled && (await hasTwilioCredentials())) {
-        const currentConfig = loadRawConfig();
-        const twilioConfig = (currentConfig?.twilio ?? {}) as Record<
-          string,
-          unknown
-        >;
-        const assignedNumbers = new Set<string>();
-        const primaryNumber = (twilioConfig.phoneNumber as string) ?? "";
-        if (primaryNumber) assignedNumbers.add(primaryNumber);
-
-        const assistantPhoneNumbers = twilioConfig.assistantPhoneNumbers;
-        if (
-          assistantPhoneNumbers &&
-          typeof assistantPhoneNumbers === "object" &&
-          !Array.isArray(assistantPhoneNumbers)
-        ) {
-          for (const number of Object.values(
-            assistantPhoneNumbers as Record<string, unknown>,
-          )) {
-            if (typeof number === "string" && number) {
-              assignedNumbers.add(number);
-            }
-          }
-        }
-
-        if (assignedNumbers.size > 0) {
-          const { accountSid: acctSid, authToken: acctToken } =
-            await getTwilioCredentials();
-          // Fire-and-forget: webhook sync failure must not block the ingress save.
-          // Reconcile every assigned number so assistant-scoped mappings do not
-          // retain stale Twilio webhook URLs after ingress URL changes.
-          for (const assignedNumber of assignedNumbers) {
-            syncTwilioWebhooks(
-              assignedNumber,
-              acctSid,
-              acctToken,
-              currentConfig as IngressConfig,
-            ).catch(() => {
-              // Already logged inside syncTwilioWebhooks
-            });
-          }
-        }
-      }
-    } else {
-      ctx.send({
-        type: "ingress_config_response",
-        enabled: false,
-        publicBaseUrl: "",
-        localGatewayTarget,
-        success: false,
-        error: `Unknown action: ${String(msg.action)}`,
-      });
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.send({
-      type: "ingress_config_response",
-      enabled: false,
-      publicBaseUrl: "",
-      localGatewayTarget,
-      success: false,
-      error: message,
-    });
-  }
-}

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

@@ -100,7 +100,7 @@ export async function getModelInfo(): Promise<ModelInfo> {
 
 /**
  * Minimal interface for the side-effects needed by setModel / setImageGenModel.
- * Keeps the business logic decoupled from transport-specific HandlerContext.
+ * Keeps the business logic decoupled from transport-specific server context.
  */
 export interface ModelSetContext {
   suppressConfigReload: boolean;

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

@@ -1,24 +1,3 @@
-import type { VoiceConfigUpdateRequest } from "../message-types/settings.js";
-import { type HandlerContext, log } from "./shared.js";
-
-/**
- * Send a client_settings_update message to all connected clients.
- * Used to push configuration changes (e.g. activation key) from the daemon
- * to macOS/iOS clients so they can apply settings immediately.
- */
-function broadcastClientSettingsUpdate(
-  key: string,
-  value: string,
-  ctx: HandlerContext,
-): void {
-  ctx.broadcast({
-    type: "client_settings_update",
-    key,
-    value,
-  });
-  log.info({ key, value }, "Broadcast client_settings_update");
-}
-
 // ── Activation key validation ────────────────────────────────────────
 
 const VALID_ACTIVATION_KEYS = ["fn", "ctrl", "fn_shift", "none"] as const;
@@ -192,24 +171,3 @@ export function normalizeActivationKey(
     reason: `Invalid activation key "${input}". Valid values: fn (Fn/Globe key), ctrl (Control key), fn_shift (Fn+Shift), none (disable PTT), or a PTTActivator JSON object.`,
   };
 }
-
-/**
- * Process a voice configuration update request from a conversation or client.
- * Validates the activation key and broadcasts the change to all connected clients.
- */
-export function handleVoiceConfigUpdate(
-  msg: VoiceConfigUpdateRequest,
-  ctx: HandlerContext,
-): void {
-  const result = normalizeActivationKey(msg.activationKey);
-  if (!result.ok) {
-    log.warn({ input: msg.activationKey }, result.reason);
-    return;
-  }
-
-  broadcastClientSettingsUpdate("activationKey", result.value, ctx);
-  log.info(
-    { activationKey: result.value },
-    "Voice config updated: activation key",
-  );
-}

package/src/daemon/handlers/conversations.ts

@@ -1,22 +1,13 @@
 import { v4 as uuid } from "uuid";
 
-import {
-  createCanonicalGuardianRequest,
-  generateCanonicalRequestCode,
-} from "../../memory/canonical-guardian-store.js";
-import {
-  clearAll,
-  getConversation,
-  updateConversationTitle,
-} from "../../memory/conversation-crud.js";
+import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
+import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
-import { redactSecrets } from "../../security/secret-scanner.js";
 import { getSubagentManager } from "../../subagent/index.js";
-import { summarizeToolInput } from "../../tools/tool-input-summary.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { truncate } from "../../util/truncate.js";
-import type { Conversation } from "../conversation.js";
+import { regenerate } from "../conversation-history.js";
 import {
   clearAllActiveConversations,
   conversationEntries,
@@ -24,125 +15,11 @@ import {
   getOrCreateConversation,
   touchConversation,
 } from "../conversation-store.js";
-import type {
-  ConfirmationResponse,
-  SecretResponse,
-  ServerMessage,
-} from "../message-protocol.js";
+import type { ConfirmationResponse } from "../message-protocol.js";
 import { normalizeConversationType } from "../message-protocol.js";
-import {
-  type HandlerContext,
-  log,
-  pendingStandaloneSecrets,
-} from "./shared.js";
-
-export function makeEventSender(params: {
-  ctx: HandlerContext;
-  conversation: Conversation;
-  conversationId: string;
-  sourceChannel: string;
-}): (event: ServerMessage) => void {
-  const { ctx, conversation, conversationId, sourceChannel } = params;
-
-  return (event: ServerMessage) => {
-    if (event.type === "confirmation_request") {
-      // ACP permission requests are handled by client-handler.ts — skip
-      // the normal registration and guardian request creation for them.
-      // The ACP handler registers its own entry with directResolve after
-      // this callback returns.
-      const isAcpPermission = "acpToolKind" in event && !!event.acpToolKind;
-
-      if (!isAcpPermission) {
-        pendingInteractions.register(event.requestId, {
-          conversation,
-          conversationId,
-          kind: "confirmation",
-          confirmationDetails: {
-            toolName: event.toolName,
-            input: event.input,
-            riskLevel: event.riskLevel,
-            executionTarget: event.executionTarget,
-            allowlistOptions: event.allowlistOptions,
-            scopeOptions: event.scopeOptions,
-            persistentDecisionsAllowed: event.persistentDecisionsAllowed,
-          },
-        });
-
-        try {
-          const trustContext = conversation.trustContext;
-          const inputRecord = event.input as Record<string, unknown>;
-          const activityRaw =
-            (typeof inputRecord.activity === "string"
-              ? inputRecord.activity
-              : undefined) ??
-            (typeof inputRecord.reason === "string"
-              ? inputRecord.reason
-              : undefined);
-          createCanonicalGuardianRequest({
-            id: event.requestId,
-            kind: "tool_approval",
-            sourceType: "desktop",
-            sourceChannel,
-            conversationId,
-            guardianPrincipalId: trustContext?.guardianPrincipalId ?? undefined,
-            toolName: event.toolName,
-            commandPreview:
-              redactSecrets(summarizeToolInput(event.toolName, inputRecord)) ||
-              undefined,
-            riskLevel: event.riskLevel,
-            activityText: activityRaw ? redactSecrets(activityRaw) : undefined,
-            executionTarget: event.executionTarget,
-            status: "pending",
-            requestCode: generateCanonicalRequestCode(),
-            expiresAt: Date.now() + 5 * 60 * 1000,
-          });
-        } catch (err) {
-          log.debug(
-            { err, requestId: event.requestId, conversationId },
-            "Failed to create canonical request from local confirmation event",
-          );
-        }
-      }
-    } else if (event.type === "secret_request") {
-      pendingInteractions.register(event.requestId, {
-        conversation,
-        conversationId,
-        kind: "secret",
-      });
-    } else if (event.type === "host_bash_request") {
-      pendingInteractions.register(event.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_bash",
-      });
-    } else if (event.type === "host_browser_request") {
-      pendingInteractions.register(event.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_browser",
-      });
-    } else if (event.type === "host_file_request") {
-      pendingInteractions.register(event.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_file",
-      });
-    } else if (event.type === "host_cu_request") {
-      pendingInteractions.register(event.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_cu",
-      });
-    }
-
-    ctx.send(event);
-  };
-}
+import { log } from "./shared.js";
 
-export function handleConfirmationResponse(
-  msg: ConfirmationResponse,
-  ctx: HandlerContext,
-): void {
+export function handleConfirmationResponse(msg: ConfirmationResponse): void {
   // Route by requestId to the conversation that originated the prompt, not by
   // the current conversation binding which may have changed since the
   // request was issued (e.g. after a conversation switch).
@@ -150,7 +27,7 @@ export function handleConfirmationResponse(
 
   for (const [conversationId, conversation] of conversationEntries()) {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
-      ctx.touchConversation(conversationId);
+      touchConversation(conversationId);
       conversation.handleConfirmationResponse(
         msg.requestId,
         decision,
@@ -169,42 +46,6 @@ export function handleConfirmationResponse(
     "No conversation found with pending confirmation for requestId",
   );
 }
-
-export function handleSecretResponse(
-  msg: SecretResponse,
-  ctx: HandlerContext,
-): void {
-  // Check standalone (non-conversation) prompts first, since they use a dedicated
-  // requestId that won't collide with conversation prompts.
-  const standalone = pendingStandaloneSecrets.get(msg.requestId);
-  if (standalone) {
-    clearTimeout(standalone.timer);
-    pendingStandaloneSecrets.delete(msg.requestId);
-    standalone.resolve({
-      value: msg.value ?? null,
-      delivery: msg.delivery ?? "store",
-    });
-    pendingInteractions.resolve(msg.requestId);
-    return;
-  }
-
-  // Route by requestId to the conversation that originated the prompt, not by
-  // the current conversation binding which may have changed since the
-  // request was issued (e.g. after a conversation switch).
-  for (const [conversationId, conversation] of conversationEntries()) {
-    if (conversation.hasPendingSecret(msg.requestId)) {
-      ctx.touchConversation(conversationId);
-      conversation.handleSecretResponse(msg.requestId, msg.value, msg.delivery);
-      pendingInteractions.resolve(msg.requestId);
-      return;
-    }
-  }
-  log.warn(
-    { requestId: msg.requestId },
-    "No conversation found with pending secret prompt for requestId",
-  );
-}
-
 /**
  * Clear all conversations and DB conversations. Returns the number of conversations cleared.
  */
@@ -222,9 +63,7 @@ export function clearAllConversations(): number {
  * Switch to an existing conversation. Returns conversation info on success,
  * or throws/returns an error result when the conversation is not found.
  */
-export async function switchConversation(
-  conversationId: string,
-): Promise<{
+export async function switchConversation(conversationId: string): Promise<{
   conversationId: string;
   title: string;
   conversationType: ReturnType<typeof normalizeConversationType>;
@@ -245,27 +84,10 @@ export async function switchConversation(
     inferenceProfile: conversation.inferenceProfile ?? undefined,
   };
 }
-/**
- * Rename a conversation. Returns true on success, false if not found.
- */
-export function renameConversation(
-  conversationId: string,
-  name: string,
-): boolean {
-  const conversation = getConversation(conversationId);
-  if (!conversation) {
-    return false;
-  }
-  updateConversationTitle(conversationId, name, 0);
-  return true;
-}
-
 /**
  * Cancel generation for a conversation. Returns true if a conversation was found and cancelled.
  */
-export function cancelGeneration(
-  conversationId: string,
-): boolean {
+export function cancelGeneration(conversationId: string): boolean {
   const conversation = findConversation(conversationId);
   if (!conversation) {
     return false;
@@ -307,7 +129,6 @@ export async function undoLastMessage(
  */
 export async function regenerateResponse(
   conversationId: string,
-  sendEvent: (event: ServerMessage) => void,
 ): Promise<{ requestId: string } | null> {
   // The caller may pass a conversation key (e.g. the macOS client's local
   // conversation ID) instead of the daemon's internal conversation ID. Resolve
@@ -319,7 +140,7 @@ export async function regenerateResponse(
   conversationId = resolvedId;
   const conversation = await getOrCreateConversation(conversationId);
   touchConversation(conversationId);
-  conversation.updateClient(sendEvent, false);
+  conversation.updateClient(broadcastMessage, false);
   const requestId = uuid();
   conversation.traceEmitter.emit("request_received", "Regenerate requested", {
     requestId,
@@ -327,7 +148,7 @@ export async function regenerateResponse(
     attributes: { source: "regenerate" },
   });
   try {
-    await conversation.regenerate(sendEvent, requestId);
+    await regenerate(conversation, requestId);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.error({ err, conversationId }, "Error regenerating message");