@vellumai/assistant 0.4.41 → 0.4.43

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

@@ -1,5 +1,3 @@
-import * as net from "node:net";
-
 import {
   getTwilioCredentials,
   hasTwilioCredentials,
@@ -17,13 +15,11 @@ import {
   shouldUsePlatformCallbacks,
 } from "../../inbound/platform-callback-registration.js";
 import {
-  getTwilioSmsWebhookUrl,
   getTwilioStatusCallbackUrl,
   getTwilioVoiceWebhookUrl,
   type IngressConfig,
 } from "../../inbound/public-ingress-urls.js";
-import { mintDaemonDeliveryToken } from "../../runtime/auth/token-service.js";
-import type { IngressConfigRequest } from "../ipc-protocol.js";
+import type { IngressConfigRequest } from "../message-protocol.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
   defineHandlers,
@@ -49,53 +45,10 @@ export function computeGatewayTarget(): string {
   return getGatewayInternalBaseUrl();
 }
 
-/**
- * Best-effort call to the gateway's internal reconcile endpoint so that
- * Telegram webhook registration is updated immediately when the ingress
- * URL changes, without requiring a gateway restart.
- */
-export function triggerGatewayReconcile(
-  ingressPublicBaseUrl: string | undefined,
-): void {
-  const gatewayBase = computeGatewayTarget();
-  const token = mintDaemonDeliveryToken();
-
-  const url = `${gatewayBase}/internal/telegram/reconcile`;
-  const body = JSON.stringify({
-    ingressPublicBaseUrl: ingressPublicBaseUrl ?? "",
-  });
-
-  fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-    body,
-    signal: AbortSignal.timeout(5_000),
-  })
-    .then((res) => {
-      if (res.ok) {
-        log.info("Gateway Telegram webhook reconcile triggered successfully");
-      } else {
-        log.warn(
-          { status: res.status },
-          "Gateway Telegram webhook reconcile returned non-OK status",
-        );
-      }
-    })
-    .catch((err) => {
-      log.debug(
-        { err },
-        "Gateway Telegram webhook reconcile failed (gateway may not be running)",
-      );
-    });
-}
-
 /**
  * Best-effort Twilio webhook sync helper.
  *
- * Computes the voice, status-callback, and SMS webhook URLs from the current
+ * Computes the voice and status-callback webhook URLs from the current
  * ingress config and pushes them to the Twilio IncomingPhoneNumber API.
  *
  * Returns `{ success, warning }`. When the update fails, `success` is false
@@ -120,15 +73,9 @@ export async function syncTwilioWebhooks(
       "webhooks/twilio/status",
       "twilio_status",
     );
-    const smsUrl = await resolveCallbackUrl(
-      () => getTwilioSmsWebhookUrl(ingressConfig),
-      "webhooks/twilio/sms",
-      "twilio_sms",
-    );
     await updatePhoneNumberWebhooks(accountSid, authToken, phoneNumber, {
       voiceUrl,
       statusCallbackUrl,
-      smsUrl,
     });
     log.info({ phoneNumber }, "Twilio webhooks configured successfully");
     return { success: true };
@@ -144,7 +91,6 @@ export async function syncTwilioWebhooks(
 
 export async function handleIngressConfig(
   msg: IngressConfigRequest,
-  socket: net.Socket,
   ctx: HandlerContext,
 ): Promise<void> {
   const localGatewayTarget = computeGatewayTarget();
@@ -153,13 +99,8 @@ export async function handleIngressConfig(
       const raw = loadRawConfig();
       const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
       const publicBaseUrl = (ingress.publicBaseUrl as string) ?? "";
-      // Backward compatibility: if `enabled` was never explicitly set,
-      // infer from whether a publicBaseUrl is configured so existing users
-      // who predate the toggle aren't silently disabled.
-      const enabled =
-        (ingress.enabled as boolean | undefined) ??
-        (publicBaseUrl ? true : false);
-      ctx.send(socket, {
+      const enabled = (ingress.enabled as boolean | undefined) ?? false;
+      ctx.send({
         type: "ingress_config_response",
         enabled,
         publicBaseUrl,
@@ -207,8 +148,7 @@ export async function handleIngressConfig(
       // `pkill -f gateway`).
       // Only export the URL when ingress is enabled; clearing it when
       // disabled ensures the gateway stops accepting inbound webhooks.
-      const isEnabled =
-        (ingress.enabled as boolean | undefined) ?? (value ? true : false);
+      const isEnabled = (ingress.enabled as boolean | undefined) ?? false;
       if (value && isEnabled) {
         setIngressPublicBaseUrl(value);
       } else if (isEnabled && getOriginalIngressEnv() !== undefined) {
@@ -221,7 +161,7 @@ export async function handleIngressConfig(
         setIngressPublicBaseUrl(undefined);
       }
 
-      ctx.send(socket, {
+      ctx.send({
         type: "ingress_config_response",
         enabled: isEnabled,
         publicBaseUrl: value,
@@ -229,18 +169,9 @@ export async function handleIngressConfig(
         success: true,
       });
 
-      // Trigger immediate Telegram webhook reconcile on the gateway so
-      // that changing the ingress URL takes effect without a restart.
-      // Called unconditionally so the gateway clears its in-memory URL
-      // when ingress is disabled, preventing stale re-registration on
-      // credential rotation.
-      // Use the effective URL from process.env (which accounts for the
-      // fallback branch above) rather than the raw `value` from the UI.
-      const effectiveUrl = isEnabled ? getIngressPublicBaseUrl() : undefined;
-
       // When containerized with a platform, register the Telegram callback
       // route so the platform knows how to forward Telegram webhooks.
-      // This must happen independently of effectiveUrl — in containerized
+      // This must happen independently of ingress URL — in containerized
       // deployments without ingress.publicBaseUrl, platform callbacks are the
       // only way to receive Telegram webhooks.
       if (shouldUsePlatformCallbacks()) {
@@ -252,19 +183,20 @@ export async function handleIngressConfig(
         });
       }
 
-      triggerGatewayReconcile(effectiveUrl);
-
       // 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 and SMS route correctly.
+      // push the new webhook URLs to Twilio so calls route correctly.
       if (isEnabled && hasTwilioCredentials()) {
         const currentConfig = loadRawConfig();
-        const smsConfig = (currentConfig?.sms ?? {}) as Record<string, unknown>;
+        const twilioConfig = (currentConfig?.twilio ?? {}) as Record<
+          string,
+          unknown
+        >;
         const assignedNumbers = new Set<string>();
-        const legacyNumber = (smsConfig.phoneNumber as string) ?? "";
-        if (legacyNumber) assignedNumbers.add(legacyNumber);
+        const primaryNumber = (twilioConfig.phoneNumber as string) ?? "";
+        if (primaryNumber) assignedNumbers.add(primaryNumber);
 
-        const assistantPhoneNumbers = smsConfig.assistantPhoneNumbers;
+        const assistantPhoneNumbers = twilioConfig.assistantPhoneNumbers;
         if (
           assistantPhoneNumbers &&
           typeof assistantPhoneNumbers === "object" &&
@@ -298,7 +230,7 @@ export async function handleIngressConfig(
         }
       }
     } else {
-      ctx.send(socket, {
+      ctx.send({
         type: "ingress_config_response",
         enabled: false,
         publicBaseUrl: "",
@@ -309,7 +241,7 @@ export async function handleIngressConfig(
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    ctx.send(socket, {
+    ctx.send({
       type: "ingress_config_response",
       enabled: false,
       publicBaseUrl: "",

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

@@ -1,5 +1,3 @@
-import * as net from "node:net";
-
 import {
   getConfig,
   loadRawConfig,
@@ -9,7 +7,7 @@ import { initializeProviders } from "../../providers/registry.js";
 import type {
   ImageGenModelSetRequest,
   ModelSetRequest,
-} from "../ipc-protocol.js";
+} from "../message-protocol.js";
 import { MODEL_TO_PROVIDER } from "../session-slash.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
@@ -18,122 +16,167 @@ import {
   log,
 } from "./shared.js";
 
-export function handleModelGet(socket: net.Socket, ctx: HandlerContext): void {
+// ---------------------------------------------------------------------------
+// Shared business logic (transport-agnostic)
+// ---------------------------------------------------------------------------
+
+export interface ModelInfo {
+  model: string;
+  provider: string;
+  configuredProviders?: string[];
+}
+
+/** Return current model configuration. */
+export function getModelInfo(): ModelInfo {
   const config = getConfig();
   const configured = Object.keys(config.apiKeys).filter(
     (k) => !!config.apiKeys[k],
   );
   if (!configured.includes("ollama")) configured.push("ollama");
-  ctx.send(socket, {
-    type: "model_info",
+  return {
     model: config.model,
     provider: config.provider,
     configuredProviders: configured,
-  });
+  };
 }
 
-export function handleModelSet(
-  msg: ModelSetRequest,
-  socket: net.Socket,
-  ctx: HandlerContext,
-): void {
-  try {
-    // If the requested model is already the current model AND the provider
-    // is already aligned with what MODEL_TO_PROVIDER expects, skip expensive
-    // reinitialization but still send model_info so the client confirms.
-    // If the provider has drifted (e.g. manual config edit), fall through
-    // so the full reinit path can repair it.
-    {
-      const current = getConfig();
-      const expectedProvider = MODEL_TO_PROVIDER[msg.model];
-      const providerAligned =
-        !expectedProvider || current.provider === expectedProvider;
-      if (msg.model === current.model && providerAligned) {
-        const configured = Object.keys(current.apiKeys).filter(
-          (k) => !!current.apiKeys[k],
-        );
-        if (!configured.includes("ollama")) configured.push("ollama");
-        ctx.send(socket, {
-          type: "model_info",
-          model: current.model,
-          provider: current.provider,
-          configuredProviders: configured,
-        });
-        return;
-      }
-    }
+/**
+ * Minimal interface for the side-effects needed by setModel / setImageGenModel.
+ * Keeps the business logic decoupled from IPC-specific HandlerContext.
+ */
+export interface ModelSetContext {
+  sessions: Map<string, { isProcessing(): boolean; dispose(): void; markStale(): void }>;
+  suppressConfigReload: boolean;
+  setSuppressConfigReload(value: boolean): void;
+  updateConfigFingerprint(): void;
+  debounceTimers: { schedule(key: string, fn: () => void, ms: number): void };
+}
 
-    // Validate API key before switching
-    const provider = MODEL_TO_PROVIDER[msg.model];
-    if (provider && provider !== "ollama") {
-      const currentConfig = getConfig();
-      if (!currentConfig.apiKeys[provider]) {
-        // Send current model_info so the client resyncs its optimistic state
-        // (don't use generic 'error' type — it would interrupt in-flight chat)
-        const configured = Object.keys(currentConfig.apiKeys).filter(
-          (k) => !!currentConfig.apiKeys[k],
-        );
-        if (!configured.includes("ollama")) configured.push("ollama");
-        ctx.send(socket, {
-          type: "model_info",
-          model: currentConfig.model,
-          provider: currentConfig.provider,
-          configuredProviders: configured,
-        });
-        return;
-      }
+/**
+ * Set the active model. Returns the resulting ModelInfo, or throws on failure.
+ * The caller is responsible for sending the response to the client.
+ */
+export function setModel(modelId: string, ctx: ModelSetContext): ModelInfo {
+  // If the requested model is already the current model AND the provider
+  // is already aligned with what MODEL_TO_PROVIDER expects, skip expensive
+  // reinitialization but still return model_info so the client confirms.
+  {
+    const current = getConfig();
+    const expectedProvider = MODEL_TO_PROVIDER[modelId];
+    const providerAligned =
+      !expectedProvider || current.provider === expectedProvider;
+    if (modelId === current.model && providerAligned) {
+      return getModelInfo();
     }
+  }
 
-    // Use raw config to avoid persisting env-var API keys to disk
-    const raw = loadRawConfig();
-    raw.model = msg.model;
-    // Infer provider from model ID to keep provider and model in sync
-    raw.provider = provider ?? raw.provider;
-
-    // Suppress the file watcher callback — handleModelSet already does
-    // the full reload sequence; a redundant watcher-triggered reload
-    // would incorrectly evict sessions created after this method returns.
-    const wasSuppressed = ctx.suppressConfigReload;
-    ctx.setSuppressConfigReload(true);
-    try {
-      saveRawConfig(raw);
-    } catch (err) {
-      ctx.setSuppressConfigReload(wasSuppressed);
-      throw err;
+  // Validate API key before switching
+  const provider = MODEL_TO_PROVIDER[modelId];
+  if (provider && provider !== "ollama") {
+    const currentConfig = getConfig();
+    if (!currentConfig.apiKeys[provider]) {
+      // Return current model_info so the client resyncs its optimistic state
+      return getModelInfo();
     }
-    ctx.debounceTimers.schedule(
-      "__suppress_reset__",
-      () => {
-        ctx.setSuppressConfigReload(false);
-      },
-      CONFIG_RELOAD_DEBOUNCE_MS,
-    );
-
-    // Re-initialize provider with the new model so LLM calls use it
-    const config = getConfig();
-    initializeProviders(config);
-
-    // Evict idle sessions immediately; mark busy ones as stale so they
-    // get recreated with the new provider once they finish processing.
-    for (const [id, session] of ctx.sessions) {
-      if (!session.isProcessing()) {
-        session.dispose();
-        ctx.sessions.delete(id);
-      } else {
-        session.markStale();
-      }
+  }
+
+  // Use raw config to avoid persisting env-var API keys to disk
+  const raw = loadRawConfig();
+  raw.model = modelId;
+  // Infer provider from model ID to keep provider and model in sync
+  raw.provider = provider ?? raw.provider;
+
+  // Suppress the file watcher callback — setModel already does
+  // the full reload sequence; a redundant watcher-triggered reload
+  // would incorrectly evict sessions created after this method returns.
+  const wasSuppressed = ctx.suppressConfigReload;
+  ctx.setSuppressConfigReload(true);
+  try {
+    saveRawConfig(raw);
+  } catch (err) {
+    ctx.setSuppressConfigReload(wasSuppressed);
+    throw err;
+  }
+  ctx.debounceTimers.schedule(
+    "__suppress_reset__",
+    () => {
+      ctx.setSuppressConfigReload(false);
+    },
+    CONFIG_RELOAD_DEBOUNCE_MS,
+  );
+
+  // Re-initialize provider with the new model so LLM calls use it
+  const config = getConfig();
+  initializeProviders(config);
+
+  // Evict idle sessions immediately; mark busy ones as stale so they
+  // get recreated with the new provider once they finish processing.
+  for (const [id, session] of ctx.sessions) {
+    if (!session.isProcessing()) {
+      session.dispose();
+      ctx.sessions.delete(id);
+    } else {
+      session.markStale();
     }
+  }
 
-    ctx.updateConfigFingerprint();
+  ctx.updateConfigFingerprint();
 
-    ctx.send(socket, {
-      type: "model_info",
-      model: config.model,
-      provider: config.provider,
-    });
+  return { model: config.model, provider: config.provider };
+}
+
+/**
+ * Set the image generation model. Throws on failure.
+ */
+export function setImageGenModel(
+  modelId: string,
+  ctx: ModelSetContext,
+): void {
+  const raw = loadRawConfig();
+  raw.imageGenModel = modelId;
+
+  const wasSuppressed = ctx.suppressConfigReload;
+  ctx.setSuppressConfigReload(true);
+  try {
+    saveRawConfig(raw);
+  } catch (err) {
+    ctx.setSuppressConfigReload(wasSuppressed);
+    throw err;
+  }
+  ctx.debounceTimers.schedule(
+    "__suppress_reset__",
+    () => {
+      ctx.setSuppressConfigReload(false);
+    },
+    CONFIG_RELOAD_DEBOUNCE_MS,
+  );
+
+  ctx.updateConfigFingerprint();
+  log.info({ model: modelId }, "Image generation model updated");
+}
+
+// ---------------------------------------------------------------------------
+// IPC handlers (delegate to shared logic)
+// ---------------------------------------------------------------------------
+
+export function handleModelGet(ctx: HandlerContext): void {
+  const info = getModelInfo();
+  ctx.send({
+    type: "model_info",
+    ...info,
+  });
+}
+
+export function handleModelSet(
+  msg: ModelSetRequest,
+  ctx: HandlerContext,
+): void {
+  try {
+    const info = setModel(msg.model, ctx);
+    ctx.send({ type: "model_info", ...info });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    ctx.send(socket, {
+    ctx.send({
       type: "error",
       message: `Failed to set model: ${message}`,
     });
@@ -142,31 +185,10 @@ export function handleModelSet(
 
 export function handleImageGenModelSet(
   msg: ImageGenModelSetRequest,
-  _socket: net.Socket,
   ctx: HandlerContext,
 ): void {
   try {
-    const raw = loadRawConfig();
-    raw.imageGenModel = msg.model;
-
-    const wasSuppressed = ctx.suppressConfigReload;
-    ctx.setSuppressConfigReload(true);
-    try {
-      saveRawConfig(raw);
-    } catch (err) {
-      ctx.setSuppressConfigReload(wasSuppressed);
-      throw err;
-    }
-    ctx.debounceTimers.schedule(
-      "__suppress_reset__",
-      () => {
-        ctx.setSuppressConfigReload(false);
-      },
-      CONFIG_RELOAD_DEBOUNCE_MS,
-    );
-
-    ctx.updateConfigFingerprint();
-    log.info({ model: msg.model }, "Image generation model updated");
+    setImageGenModel(msg.model, ctx);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.error({ err }, `Failed to set image gen model: ${message}`);
@@ -174,7 +196,7 @@ export function handleImageGenModelSet(
 }
 
 export const modelHandlers = defineHandlers({
-  model_get: (_msg, socket, ctx) => handleModelGet(socket, ctx),
+  model_get: (_msg, ctx) => handleModelGet(ctx),
   model_set: handleModelSet,
   image_gen_model_set: handleImageGenModelSet,
 });

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

@@ -1,3 +1,10 @@
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
 import {
   deleteSecureKeyAsync,
   getSecureKey,
@@ -5,7 +12,6 @@ import {
 } from "../../security/secure-keys.js";
 import {
   deleteCredentialMetadata,
-  getCredentialMetadata,
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
 import { log as _log } from "./shared.js";
@@ -25,37 +31,21 @@ export interface SlackChannelConfigResult {
   warning?: string;
 }
 
-// -- Metadata stored as JSON in accountInfo --
-
-interface SlackChannelMetadata {
-  teamId?: string;
-  teamName?: string;
-  botUserId?: string;
-  botUsername?: string;
-}
-
-function parseMetadata(raw: string | undefined): SlackChannelMetadata {
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw) as SlackChannelMetadata;
-  } catch {
-    return {};
-  }
-}
-
 // -- Business logic --
 
 export function getSlackChannelConfig(): SlackChannelConfigResult {
   const hasBotToken = !!getSecureKey("credential:slack_channel:bot_token");
   const hasAppToken = !!getSecureKey("credential:slack_channel:app_token");
-  const meta = getCredentialMetadata("slack_channel", "bot_token");
-  const metadata = parseMetadata(meta?.accountInfo);
+  const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
   return {
     success: true,
     hasBotToken,
     hasAppToken,
     connected: hasBotToken && hasAppToken,
-    ...metadata,
+    ...(teamId ? { teamId } : {}),
+    ...(teamName ? { teamName } : {}),
+    ...(botUserId ? { botUserId } : {}),
+    ...(botUsername ? { botUsername } : {}),
   };
 }
 
@@ -63,7 +53,12 @@ export async function setSlackChannelConfig(
   botToken?: string,
   appToken?: string,
 ): Promise<SlackChannelConfigResult> {
-  let metadata: SlackChannelMetadata = {};
+  let metadata: {
+    teamId?: string;
+    teamName?: string;
+    botUserId?: string;
+    botUsername?: string;
+  } = {};
   let warning: string | undefined;
 
   // Validate and store bot token
@@ -142,13 +137,24 @@ export async function setSlackChannelConfig(
       };
     }
 
-    upsertCredentialMetadata("slack_channel", "bot_token", {
-      accountInfo: JSON.stringify(metadata),
-    });
+    upsertCredentialMetadata("slack_channel", "bot_token", {});
+
+    const raw = loadRawConfig();
+    setNestedValue(raw, "slack.teamId", metadata.teamId ?? "");
+    setNestedValue(raw, "slack.teamName", metadata.teamName ?? "");
+    setNestedValue(raw, "slack.botUserId", metadata.botUserId ?? "");
+    setNestedValue(raw, "slack.botUsername", metadata.botUsername ?? "");
+    saveRawConfig(raw);
+    invalidateConfigCache();
   } else {
-    // Use existing metadata if no new bot token provided
-    const existingMeta = getCredentialMetadata("slack_channel", "bot_token");
-    metadata = parseMetadata(existingMeta?.accountInfo);
+    // Use existing metadata from config if no new bot token provided
+    const { teamId, teamName, botUserId, botUsername } = getConfig().slack;
+    metadata = {
+      ...(teamId ? { teamId } : {}),
+      ...(teamName ? { teamName } : {}),
+      ...(botUserId ? { botUserId } : {}),
+      ...(botUsername ? { botUsername } : {}),
+    };
   }
 
   // Validate and store app token
@@ -232,6 +238,14 @@ export async function clearSlackChannelConfig(): Promise<SlackChannelConfigResul
   deleteCredentialMetadata("slack_channel", "bot_token");
   deleteCredentialMetadata("slack_channel", "app_token");
 
+  const raw = loadRawConfig();
+  setNestedValue(raw, "slack.teamId", "");
+  setNestedValue(raw, "slack.teamName", "");
+  setNestedValue(raw, "slack.botUserId", "");
+  setNestedValue(raw, "slack.botUsername", "");
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
   return {
     success: true,
     hasBotToken: false,