@vellumai/assistant 0.4.41 → 0.4.43

package/src/memory/app-migration.ts

@@ -1,114 +0,0 @@
-/**
- * One-way migration helper: converts legacy single-HTML apps to the
- * multi-file src/ layout (formatVersion 2).
- *
- * Non-destructive — the root index.html is preserved as a legacy fallback.
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { getApp, getAppsDir, isMultifileApp } from "./app-store.js";
-
-export interface MigrationResult {
-  ok: boolean;
-  error?: string;
-}
-
-/**
- * Extract inline `<style>` blocks from HTML, returning the extracted CSS
- * and the HTML with those blocks replaced by a `<link>` tag.
- */
-function extractInlineStyles(html: string): {
-  css: string;
-  html: string;
-} {
-  const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
-  const cssChunks: string[] = [];
-
-  for (const match of html.matchAll(styleRegex)) {
-    cssChunks.push(match[1].trim());
-  }
-
-  if (cssChunks.length === 0) {
-    return { css: "", html };
-  }
-
-  const css = cssChunks.join("\n\n");
-
-  // Replace the first <style> block with a <link> tag, remove the rest
-  let replaced = false;
-  const updatedHtml = html.replace(styleRegex, () => {
-    if (!replaced) {
-      replaced = true;
-      return `<link rel="stylesheet" href="styles.css">`;
-    }
-    return "";
-  });
-
-  return { css, html: updatedHtml };
-}
-
-/**
- * Migrate a legacy single-HTML app to the multi-file src/ layout.
- *
- * Steps:
- *   1. Read existing index.html
- *   2. Create {appId}/src/ directory
- *   3. Copy HTML content to src/index.html (with inline styles extracted)
- *   4. Create src/main.tsx placeholder entry point
- *   5. If inline styles found, write src/styles.css
- *   6. Update app metadata to formatVersion: 2
- *   7. Keep root index.html untouched (legacy fallback)
- */
-export function migrateAppToMultifile(appId: string): MigrationResult {
-  const app = getApp(appId);
-  if (!app) {
-    return { ok: false, error: `App not found: ${appId}` };
-  }
-
-  // Already migrated — treat as no-op
-  if (isMultifileApp(app)) {
-    return { ok: true };
-  }
-
-  const appsDir = getAppsDir();
-  const appDir = join(appsDir, appId);
-  const rootIndex = join(appDir, "index.html");
-
-  if (!existsSync(rootIndex)) {
-    return { ok: false, error: `Root index.html not found for app ${appId}` };
-  }
-
-  const originalHtml = readFileSync(rootIndex, "utf-8");
-
-  // Create src/ directory
-  const srcDir = join(appDir, "src");
-  mkdirSync(srcDir, { recursive: true });
-
-  // Extract inline styles if present
-  const { css, html: processedHtml } = extractInlineStyles(originalHtml);
-
-  // Write src/index.html
-  writeFileSync(join(srcDir, "index.html"), processedHtml, "utf-8");
-
-  // Write src/main.tsx placeholder
-  const styleImport = css ? "import './styles.css';\n" : "";
-  const mainTsx = `// Entry point — migrated from legacy single-file app\n${styleImport}\nconsole.log('App loaded');\n`;
-  writeFileSync(join(srcDir, "main.tsx"), mainTsx, "utf-8");
-
-  // Write src/styles.css if styles were extracted
-  if (css) {
-    writeFileSync(join(srcDir, "styles.css"), css, "utf-8");
-  }
-
-  // Update metadata to formatVersion 2
-  const metadataPath = join(appsDir, `${appId}.json`);
-  const rawMeta = readFileSync(metadataPath, "utf-8");
-  const metadata = JSON.parse(rawMeta);
-  metadata.formatVersion = 2;
-  metadata.updatedAt = Date.now();
-  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
-
-  return { ok: true };
-}

package/src/memory/channel-delivery-store.ts

@@ -1,40 +0,0 @@
-/**
- * Channel inbound idempotency + delivery state tracking.
- *
- * This module re-exports from focused sub-modules for backward compatibility.
- * New code should import directly from the relevant sub-module:
- *   - delivery-crud.ts    — inbound event CRUD and payload management
- *   - delivery-status.ts  — processing status tracking and dead-letter queue
- *   - delivery-channels.ts — verification replies, segment progress, delivery guards
- */
-
-export type { PendingVerificationReply } from "./delivery-channels.js";
-export {
-  claimRunDelivery,
-  clearPendingVerificationReply,
-  getDeliveredSegmentCount,
-  getPendingVerificationReply,
-  resetAllRunDeliveryClaims,
-  resetRunDeliveryClaim,
-  storePendingVerificationReply,
-  updateDeliveredSegmentCount,
-} from "./delivery-channels.js";
-export type { InboundResult, RecordInboundOptions } from "./delivery-crud.js";
-export {
-  clearPayload,
-  deleteInbound,
-  findMessageBySourceId,
-  getLatestStoredPayload,
-  linkMessage,
-  recordInbound,
-  storePayload,
-} from "./delivery-crud.js";
-export {
-  acknowledgeDelivery,
-  getDeadLetterEvents,
-  getRetryableEvents,
-  markProcessed,
-  markRetryableFailure,
-  recordProcessingFailure,
-  replayDeadLetters,
-} from "./delivery-status.js";

package/src/memory/channel-guardian-store.ts

@@ -1,83 +0,0 @@
-/**
- * Re-export hub for channel guardian store modules.
- *
- * The implementation has been split into focused modules:
- * - guardian-verification.ts — verification challenge/session management
- * - guardian-approvals.ts   — approval request tracking
- * - guardian-rate-limits.ts — verification rate limiting
- *
- * Guardian binding types (GuardianBinding, BindingStatus) are defined locally
- * here.
- *
- * This file re-exports everything for backward compatibility.
- */
-
-// ---------------------------------------------------------------------------
-// Guardian binding types
-// ---------------------------------------------------------------------------
-
-export type BindingStatus = "active" | "revoked";
-
-export interface GuardianBinding {
-  id: string;
-  assistantId: string;
-  channel: string;
-  guardianExternalUserId: string;
-  guardianDeliveryChatId: string;
-  guardianPrincipalId: string;
-  status: BindingStatus;
-  verifiedAt: number;
-  verifiedVia: string;
-  metadataJson: string | null;
-  createdAt: number;
-  updatedAt: number;
-}
-
-// ---------------------------------------------------------------------------
-// Re-exports from focused modules
-// ---------------------------------------------------------------------------
-
-export {
-  type ApprovalRequestStatus,
-  countPendingByConversation,
-  // @internal — test-only helpers; production code uses canonical-guardian-store
-  createApprovalRequest,
-  findPendingAccessRequestForRequester,
-  getAllPendingApprovalsByGuardianChat,
-  getApprovalRequestById,
-  getExpiredPendingApprovals,
-  getPendingApprovalByGuardianChat,
-  getPendingApprovalByRequestAndGuardianChat,
-  getPendingApprovalForRequest,
-  getUnresolvedApprovalForRequest,
-  type GuardianApprovalRequest,
-  listPendingApprovalRequests,
-  resolveApprovalRequest,
-  updateApprovalDecision,
-} from "./guardian-approvals.js";
-export {
-  getRateLimit,
-  recordInvalidAttempt,
-  resetRateLimit,
-  type VerificationRateLimit,
-} from "./guardian-rate-limits.js";
-export {
-  bindSessionIdentity,
-  type ChallengeStatus,
-  consumeChallenge,
-  countRecentSendsToDestination,
-  createChallenge,
-  createVerificationSession,
-  findActiveSession,
-  findPendingChallengeByHash,
-  findPendingChallengeForChannel,
-  findSessionByBootstrapTokenHash,
-  findSessionByIdentity,
-  type IdentityBindingStatus,
-  revokePendingChallenges,
-  type SessionStatus,
-  updateSessionDelivery,
-  updateSessionStatus,
-  type VerificationChallenge,
-  type VerificationPurpose,
-} from "./guardian-verification.js";

package/src/memory/conversation-store.ts

@@ -1,102 +0,0 @@
-// Re-export all conversation store functionality from focused sub-modules.
-// Existing imports from this file continue to work without changes.
-
-import { ensureDisplayOrderMigration } from "./conversation-display-order-migration.js";
-import { rawExec, rawGet, rawRun } from "./db.js";
-
-export {
-  addMessage,
-  clearAll,
-  type ConversationRow,
-  createConversation,
-  deleteConversation,
-  type DeletedMemoryIds,
-  deleteLastExchange,
-  deleteMessageById,
-  getConversation,
-  getConversationMemoryScopeId,
-  getConversationOriginChannel,
-  getConversationOriginInterface,
-  getConversationRecentProvenanceTrustClass,
-  getConversationThreadType,
-  getMessageById,
-  getMessages,
-  type MessageMetadata,
-  messageMetadataSchema,
-  type MessageRow,
-  parseConversation,
-  parseMessage,
-  provenanceFromTrustContext,
-  relinkAttachments,
-  setConversationOriginChannelIfUnset,
-  setConversationOriginInterfaceIfUnset,
-  updateConversationContextWindow,
-  updateConversationTitle,
-  updateConversationUsage,
-  updateMessageContent,
-} from "./conversation-crud.js";
-export {
-  type ConversationSearchResult,
-  countConversations,
-  getLatestConversation,
-  getMessagesPaginated,
-  getNextMessage,
-  isLastUserMessageToolResult,
-  listConversations,
-  type PaginatedMessagesResult,
-  searchConversations,
-} from "./conversation-queries.js";
-
-// Re-export for backward compat — callers that imported ensureColumns from here
-export { ensureDisplayOrderMigration as ensureColumns } from "./conversation-display-order-migration.js";
-
-// ---------------------------------------------------------------------------
-// CRUD functions for display_order and is_pinned
-// ---------------------------------------------------------------------------
-
-export function batchSetDisplayOrders(
-  updates: Array<{
-    id: string;
-    displayOrder: number | null;
-    isPinned: boolean;
-  }>,
-): void {
-  ensureDisplayOrderMigration();
-  rawExec("BEGIN");
-  try {
-    for (const update of updates) {
-      rawRun(
-        "UPDATE conversations SET display_order = ?, is_pinned = ? WHERE id = ?",
-        update.displayOrder,
-        update.isPinned ? 1 : 0,
-        update.id,
-      );
-    }
-    rawExec("COMMIT");
-  } catch (err) {
-    rawExec("ROLLBACK");
-    throw err;
-  }
-}
-
-export function getDisplayMetaForConversations(
-  conversationIds: string[],
-): Map<string, { displayOrder: number | null; isPinned: boolean }> {
-  ensureDisplayOrderMigration();
-  const result = new Map<
-    string,
-    { displayOrder: number | null; isPinned: boolean }
-  >();
-  if (conversationIds.length === 0) return result;
-  for (const id of conversationIds) {
-    const row = rawGet<{
-      display_order: number | null;
-      is_pinned: number | null;
-    }>("SELECT display_order, is_pinned FROM conversations WHERE id = ?", id);
-    result.set(id, {
-      displayOrder: row?.display_order ?? null,
-      isPinned: (row?.is_pinned ?? 0) === 1,
-    });
-  }
-  return result;
-}

package/src/memory/schema-migration.ts

@@ -1,38 +0,0 @@
-// Re-export all migrations from individual files for backward compatibility.
-export {
-  migrateAddOriginInterface,
-  migrateAssistantIdToSelf,
-  migrateBackfillInboxThreadStateFromBindings,
-  migrateCallSessionsAddInitiatedFrom,
-  migrateCallSessionsProviderSidDedup,
-  migrateDropActiveSearchIndex,
-  migrateEmbeddingVectorBlob,
-  migrateExtConvBindingsChannelChatUnique,
-  migrateGuardianActionTables,
-  migrateJobDeferrals,
-  migrateLlmUsageEventsDropAssistantId,
-  migrateMemoryEntityRelationDedup,
-  migrateMemoryFtsBackfill,
-  migrateMemoryItemsFingerprintScopeUnique,
-  migrateMemoryItemsIndexes,
-  migrateMemoryItemSourcesIndexes,
-  migrateMemoryItemsScopeSaltedFingerprints,
-  migrateMemorySegmentsIndexes,
-  migrateMessagesFtsBackfill,
-  migrateNormalizePhoneIdentities,
-  migrateNotificationDeliveryPairingColumns,
-  migrateNotificationDeliveryThreadDecision,
-  migrateNotificationTablesSchema,
-  migrateRemainingTableIndexes,
-  migrateReminderRoutingIntent,
-  migrateRemoveAssistantIdColumns,
-  migrateSchemaIndexesAndColumns,
-  migrateToolInvocationsFk,
-  migrateUsageDashboardIndexes,
-  MIGRATION_REGISTRY,
-  type MigrationRegistryEntry,
-  type MigrationValidationResult,
-  recoverCrashedMigrations,
-  validateMigrationState,
-  withCrashRecovery,
-} from "./migrations/index.js";

package/src/messaging/providers/sms/adapter.ts

@@ -1,232 +0,0 @@
-/**
- * SMS messaging provider adapter.
- *
- * Enables proactive outbound SMS messaging via the gateway's /deliver/sms
- * endpoint. Similar to the Telegram provider, SMS delivery is proxied through
- * the gateway which owns the Twilio credentials and handles the Messages API.
- *
- * Twilio credentials (account_sid, auth_token) and a configured phone number
- * are required for connectivity. The phone number is resolved from the config
- * (sms.phoneNumber), env var (TWILIO_PHONE_NUMBER), or secure key fallback.
- *
- * The `token` parameter in MessagingProvider methods is unused for SMS
- * because delivery is authenticated via the gateway's bearer token, not
- * a per-user OAuth token.
- */
-
-import {
-  getTwilioCredentials,
-  hasTwilioCredentials,
-} from "../../../calls/twilio-rest.js";
-import {
-  getGatewayInternalBaseUrl,
-  getTwilioPhoneNumberEnv,
-} from "../../../config/env.js";
-import { loadConfig } from "../../../config/loader.js";
-import { getOrCreateConversation } from "../../../memory/conversation-key-store.js";
-import * as externalConversationStore from "../../../memory/external-conversation-store.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../../runtime/assistant-scope.js";
-import { mintDaemonDeliveryToken } from "../../../runtime/auth/token-service.js";
-import { getSecureKey } from "../../../security/secure-keys.js";
-import type { MessagingProvider } from "../../provider.js";
-import type {
-  ConnectionInfo,
-  Conversation,
-  HistoryOptions,
-  ListOptions,
-  Message,
-  SearchOptions,
-  SearchResult,
-  SendOptions,
-  SendResult,
-} from "../../provider-types.js";
-import * as sms from "./client.js";
-
-/** Resolve the gateway base URL, preferring GATEWAY_INTERNAL_BASE_URL if set. */
-function getGatewayUrl(): string {
-  return getGatewayInternalBaseUrl();
-}
-
-/** Mint a short-lived JWT for authenticating with the gateway. */
-function getBearerToken(): string {
-  return mintDaemonDeliveryToken();
-}
-
-/** Resolve the configured SMS phone number. */
-function getPhoneNumber(): string | undefined {
-  const fromEnv = getTwilioPhoneNumberEnv();
-  if (fromEnv) return fromEnv;
-
-  try {
-    const config = loadConfig();
-    if (config.sms?.phoneNumber) return config.sms.phoneNumber;
-  } catch {
-    // Config may not be available yet during early startup
-  }
-
-  return getSecureKey("credential:twilio:phone_number") || undefined;
-}
-
-export const smsMessagingProvider: MessagingProvider = {
-  id: "sms",
-  displayName: "SMS",
-  credentialService: "twilio",
-  capabilities: new Set(["send"]),
-
-  /**
-   * SMS is connected when Twilio credentials are stored AND a phone number
-   * is configured. Without a phone number the gateway cannot determine
-   * the `from` for outbound messages.
-   */
-  isConnected(): boolean {
-    if (!hasTwilioCredentials()) return false;
-    if (getPhoneNumber()) return true;
-    try {
-      const config = loadConfig();
-      const mappings = config.sms?.assistantPhoneNumbers as
-        | Record<string, string>
-        | undefined;
-      if (mappings && Object.keys(mappings).length > 0) return true;
-    } catch {
-      // Config may not be available yet
-    }
-    return false;
-  },
-
-  async testConnection(_token: string): Promise<ConnectionInfo> {
-    if (!hasTwilioCredentials()) {
-      return {
-        connected: false,
-        user: "unknown",
-        platform: "sms",
-        metadata: {
-          error: "No Twilio credentials found. Run the twilio-setup skill.",
-        },
-      };
-    }
-
-    const phoneNumber = getPhoneNumber();
-    if (!phoneNumber) {
-      // Mirror isConnected(): fall back to assistant-scoped phone numbers
-      try {
-        const config = loadConfig();
-        const mappings = config.sms?.assistantPhoneNumbers as
-          | Record<string, string>
-          | undefined;
-        if (mappings && Object.keys(mappings).length > 0) {
-          const accountSid = getTwilioCredentials().accountSid;
-          return {
-            connected: true,
-            user: "assistant-scoped",
-            platform: "sms",
-            metadata: {
-              accountSid: accountSid.slice(0, 6) + "...",
-              assistantPhoneNumbers: Object.keys(mappings).length,
-            },
-          };
-        }
-      } catch {
-        // Config may not be available yet
-      }
-      return {
-        connected: false,
-        user: "unknown",
-        platform: "sms",
-        metadata: {
-          error:
-            "No phone number configured. Run the twilio-setup skill to assign a number.",
-        },
-      };
-    }
-
-    const accountSid = getTwilioCredentials().accountSid;
-
-    return {
-      connected: true,
-      user: phoneNumber,
-      platform: "sms",
-      metadata: {
-        accountSid: accountSid.slice(0, 6) + "...",
-        phoneNumber,
-      },
-    };
-  },
-
-  async sendMessage(
-    _token: string,
-    conversationId: string,
-    text: string,
-    options?: SendOptions,
-  ): Promise<SendResult> {
-    const gatewayUrl = getGatewayUrl();
-    const bearerToken = getBearerToken();
-    const assistantId = options?.assistantId;
-
-    const sendResult = await sms.sendMessage(
-      gatewayUrl,
-      bearerToken,
-      conversationId,
-      text,
-      assistantId,
-    );
-
-    // Upsert external conversation binding so the conversation key mapping
-    // exists for the next inbound SMS from this number.
-    const isSelfScope =
-      !assistantId || assistantId === DAEMON_INTERNAL_ASSISTANT_ID;
-    try {
-      const sourceChannel = "sms";
-      const conversationKey = isSelfScope
-        ? `${sourceChannel}:${conversationId}`
-        : `asst:${assistantId}:${sourceChannel}:${conversationId}`;
-      const { conversationId: internalId } =
-        getOrCreateConversation(conversationKey);
-      if (isSelfScope) {
-        externalConversationStore.upsertOutboundBinding({
-          conversationId: internalId,
-          sourceChannel,
-          externalChatId: conversationId,
-        });
-      }
-    } catch {
-      // Best-effort — don't fail the send if binding upsert fails
-    }
-
-    // Use the Twilio message SID as the send result ID when available,
-    // falling back to a timestamp-based ID for older gateway versions.
-    const id = sendResult.messageSid || `sms-${Date.now()}`;
-
-    return {
-      id,
-      timestamp: Date.now(),
-      conversationId,
-    };
-  },
-
-  // SMS does not support listing conversations. The assistant can only
-  // send to known phone numbers (conversation IDs).
-  async listConversations(
-    _token: string,
-    _options?: ListOptions,
-  ): Promise<Conversation[]> {
-    return [];
-  },
-
-  // SMS does not provide message history retrieval via the gateway.
-  async getHistory(
-    _token: string,
-    _conversationId: string,
-    _options?: HistoryOptions,
-  ): Promise<Message[]> {
-    return [];
-  },
-
-  // SMS does not support message search.
-  async search(
-    _token: string,
-    _query: string,
-    _options?: SearchOptions,
-  ): Promise<SearchResult> {
-    return { total: 0, messages: [], hasMore: false };
-  },
-};

package/src/messaging/providers/sms/client.ts

@@ -1,93 +0,0 @@
-/**
- * Low-level SMS operations.
- *
- * Outbound message delivery routes through the gateway's /deliver/sms
- * endpoint, which handles Twilio credential management and the Messages API.
- * The gateway resolves the `from` number using the optional assistantId or
- * its default Twilio phone number configuration.
- */
-
-const DELIVERY_TIMEOUT_MS = 30_000;
-
-export class SmsApiError extends Error {
-  constructor(
-    public readonly status: number,
-    message: string,
-  ) {
-    super(message);
-    this.name = "SmsApiError";
-  }
-}
-
-/** Payload accepted by the gateway's /deliver/sms endpoint. */
-interface DeliverPayload {
-  to: string;
-  text: string;
-  assistantId?: string;
-}
-
-/** Result returned by sendMessage with Twilio acceptance details. */
-export interface SmsSendResult {
-  messageSid?: string;
-  status?: string;
-  errorCode?: string | null;
-  errorMessage?: string | null;
-}
-
-/**
- * Send an SMS message via the gateway's /deliver/sms endpoint.
- *
- * Returns Twilio acceptance details propagated from the gateway.
- * "Accepted" means Twilio received it for delivery -- it has NOT yet
- * been confirmed as delivered to the handset.
- */
-export async function sendMessage(
-  gatewayUrl: string,
-  bearerToken: string,
-  to: string,
-  text: string,
-  assistantId?: string,
-): Promise<SmsSendResult> {
-  const payload: DeliverPayload = { to, text };
-  if (assistantId) {
-    payload.assistantId = assistantId;
-  }
-
-  const url = `${gatewayUrl}/deliver/sms`;
-  const resp = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${bearerToken}`,
-    },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(DELIVERY_TIMEOUT_MS),
-  });
-
-  if (!resp.ok) {
-    const body = await resp.text().catch(() => "<unreadable>");
-    throw new SmsApiError(
-      resp.status,
-      `Gateway /deliver/sms failed (${resp.status}): ${body}`,
-    );
-  }
-
-  try {
-    const data = (await resp.json()) as {
-      ok?: boolean;
-      messageSid?: string;
-      status?: string;
-      errorCode?: string | null;
-      errorMessage?: string | null;
-    };
-    return {
-      messageSid: data.messageSid,
-      status: data.status,
-      errorCode: data.errorCode,
-      errorMessage: data.errorMessage,
-    };
-  } catch {
-    // Older gateway versions may not return JSON with Twilio details
-    return {};
-  }
-}