@vellumai/assistant 0.4.30 → 0.4.32

package/src/memory/schema/calls.ts

@@ -0,0 +1,274 @@
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
+import { conversations } from "./conversations.js";
+
+export const callSessions = sqliteTable(
+  "call_sessions",
+  {
+    id: text("id").primaryKey(),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    provider: text("provider").notNull(),
+    providerCallSid: text("provider_call_sid"),
+    fromNumber: text("from_number").notNull(),
+    toNumber: text("to_number").notNull(),
+    task: text("task"),
+    status: text("status").notNull().default("initiated"),
+    callMode: text("call_mode"),
+    guardianVerificationSessionId: text("guardian_verification_session_id"),
+    callerIdentityMode: text("caller_identity_mode"),
+    callerIdentitySource: text("caller_identity_source"),
+    assistantId: text("assistant_id"),
+    initiatedFromConversationId: text("initiated_from_conversation_id"),
+    startedAt: integer("started_at"),
+    endedAt: integer("ended_at"),
+    lastError: text("last_error"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [index("idx_call_sessions_status").on(table.status)],
+);
+
+export const callEvents = sqliteTable("call_events", {
+  id: text("id").primaryKey(),
+  callSessionId: text("call_session_id")
+    .notNull()
+    .references(() => callSessions.id, { onDelete: "cascade" }),
+  eventType: text("event_type").notNull(),
+  payloadJson: text("payload_json").notNull().default("{}"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const callPendingQuestions = sqliteTable("call_pending_questions", {
+  id: text("id").primaryKey(),
+  callSessionId: text("call_session_id")
+    .notNull()
+    .references(() => callSessions.id, { onDelete: "cascade" }),
+  questionText: text("question_text").notNull(),
+  status: text("status").notNull().default("pending"),
+  askedAt: integer("asked_at").notNull(),
+  answeredAt: integer("answered_at"),
+  answerText: text("answer_text"),
+});
+
+export const processedCallbacks = sqliteTable("processed_callbacks", {
+  id: text("id").primaryKey(),
+  dedupeKey: text("dedupe_key").notNull().unique(),
+  callSessionId: text("call_session_id")
+    .notNull()
+    .references(() => callSessions.id, { onDelete: "cascade" }),
+  claimId: text("claim_id"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const externalConversationBindings = sqliteTable(
+  "external_conversation_bindings",
+  {
+    conversationId: text("conversation_id")
+      .primaryKey()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    sourceChannel: text("source_channel").notNull(),
+    externalChatId: text("external_chat_id").notNull(),
+    externalUserId: text("external_user_id"),
+    displayName: text("display_name"),
+    username: text("username"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    lastInboundAt: integer("last_inbound_at"),
+    lastOutboundAt: integer("last_outbound_at"),
+  },
+);
+
+export const channelGuardianVerificationChallenges = sqliteTable(
+  "channel_guardian_verification_challenges",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id").notNull(),
+    channel: text("channel").notNull(),
+    challengeHash: text("challenge_hash").notNull(),
+    expiresAt: integer("expires_at").notNull(),
+    status: text("status").notNull().default("pending"),
+    createdBySessionId: text("created_by_session_id"),
+    consumedByExternalUserId: text("consumed_by_external_user_id"),
+    consumedByChatId: text("consumed_by_chat_id"),
+    // Outbound session: expected-identity binding
+    expectedExternalUserId: text("expected_external_user_id"),
+    expectedChatId: text("expected_chat_id"),
+    expectedPhoneE164: text("expected_phone_e164"),
+    identityBindingStatus: text("identity_binding_status").default("bound"),
+    // Outbound session: delivery tracking
+    destinationAddress: text("destination_address"),
+    lastSentAt: integer("last_sent_at"),
+    sendCount: integer("send_count").default(0),
+    nextResendAt: integer("next_resend_at"),
+    // Session configuration
+    codeDigits: integer("code_digits").default(6),
+    maxAttempts: integer("max_attempts").default(3),
+    // Distinguishes guardian verification from trusted contact verification
+    verificationPurpose: text("verification_purpose").default("guardian"),
+    // Telegram bootstrap deep-link token hash
+    bootstrapTokenHash: text("bootstrap_token_hash"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const channelGuardianApprovalRequests = sqliteTable(
+  "channel_guardian_approval_requests",
+  {
+    id: text("id").primaryKey(),
+    runId: text("run_id").notNull(),
+    requestId: text("request_id"),
+    conversationId: text("conversation_id").notNull(),
+    assistantId: text("assistant_id")
+      .notNull()
+      .default(DAEMON_INTERNAL_ASSISTANT_ID),
+    channel: text("channel").notNull(),
+    requesterExternalUserId: text("requester_external_user_id").notNull(),
+    requesterChatId: text("requester_chat_id").notNull(),
+    guardianExternalUserId: text("guardian_external_user_id").notNull(),
+    guardianChatId: text("guardian_chat_id").notNull(),
+    toolName: text("tool_name").notNull(),
+    riskLevel: text("risk_level"),
+    reason: text("reason"),
+    status: text("status").notNull().default("pending"),
+    decidedByExternalUserId: text("decided_by_external_user_id"),
+    expiresAt: integer("expires_at").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const channelGuardianRateLimits = sqliteTable(
+  "channel_guardian_rate_limits",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id").notNull(),
+    channel: text("channel").notNull(),
+    actorExternalUserId: text("actor_external_user_id").notNull(),
+    actorChatId: text("actor_chat_id").notNull(),
+    // Legacy columns kept with defaults for backward compatibility with upgraded databases
+    // that still have the old NOT NULL columns without DEFAULT. Not read by app logic.
+    invalidAttempts: integer("invalid_attempts").notNull().default(0),
+    windowStartedAt: integer("window_started_at").notNull().default(0),
+    attemptTimestampsJson: text("attempt_timestamps_json")
+      .notNull()
+      .default("[]"),
+    lockedUntil: integer("locked_until"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const mediaAssets = sqliteTable("media_assets", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  filePath: text("file_path").notNull(),
+  mimeType: text("mime_type").notNull(),
+  durationSeconds: real("duration_seconds"),
+  fileHash: text("file_hash").notNull(),
+  status: text("status").notNull().default("registered"), // registered | processing | indexed | failed
+  mediaType: text("media_type").notNull(), // video | audio | image
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const processingStages = sqliteTable("processing_stages", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  stage: text("stage").notNull(),
+  status: text("status").notNull().default("pending"), // pending | running | completed | failed
+  progress: integer("progress").notNull().default(0), // 0-100
+  lastError: text("last_error"),
+  startedAt: integer("started_at"),
+  completedAt: integer("completed_at"),
+});
+
+export const mediaKeyframes = sqliteTable("media_keyframes", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  timestamp: real("timestamp").notNull(),
+  filePath: text("file_path").notNull(),
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaVisionOutputs = sqliteTable("media_vision_outputs", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  keyframeId: text("keyframe_id")
+    .notNull()
+    .references(() => mediaKeyframes.id, { onDelete: "cascade" }),
+  analysisType: text("analysis_type").notNull(),
+  output: text("output").notNull(), // JSON
+  confidence: real("confidence"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaTimelines = sqliteTable("media_timelines", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  startTime: real("start_time").notNull(),
+  endTime: real("end_time").notNull(),
+  segmentType: text("segment_type").notNull(),
+  attributes: text("attributes"), // JSON
+  confidence: real("confidence"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaEvents = sqliteTable("media_events", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  eventType: text("event_type").notNull(),
+  startTime: real("start_time").notNull(),
+  endTime: real("end_time").notNull(),
+  confidence: real("confidence").notNull(),
+  reasons: text("reasons").notNull(), // JSON array
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaTrackingProfiles = sqliteTable("media_tracking_profiles", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  capabilities: text("capabilities").notNull(), // JSON: { [capName]: { enabled, tier } }
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaEventFeedback = sqliteTable("media_event_feedback", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  eventId: text("event_id")
+    .notNull()
+    .references(() => mediaEvents.id, { onDelete: "cascade" }),
+  feedbackType: text("feedback_type").notNull(), // correct | incorrect | boundary_edit | missed
+  originalStartTime: real("original_start_time"),
+  originalEndTime: real("original_end_time"),
+  correctedStartTime: real("corrected_start_time"),
+  correctedEndTime: real("corrected_end_time"),
+  notes: text("notes"),
+  createdAt: integer("created_at").notNull(),
+});

package/src/memory/schema/contacts.ts

@@ -0,0 +1,125 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
+import { conversations } from "./conversations.js";
+
+export const contacts = sqliteTable("contacts", {
+  id: text("id").primaryKey(),
+  displayName: text("display_name").notNull(),
+  notes: text("notes"),
+  lastInteraction: integer("last_interaction"), // epoch ms
+  interactionCount: integer("interaction_count").notNull().default(0),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+  role: text("role").notNull().default("contact"), // 'guardian' | 'contact'
+  principalId: text("principal_id"), // internal auth principal (nullable)
+  assistantId: text("assistant_id"), // which assistant this guardian is for (nullable, daemon default is DAEMON_INTERNAL_ASSISTANT_ID)
+  contactType: text("contact_type").notNull().default("human"), // 'human' | 'assistant'
+});
+
+export const contactChannels = sqliteTable(
+  "contact_channels",
+  {
+    id: text("id").primaryKey(),
+    contactId: text("contact_id")
+      .notNull()
+      .references(() => contacts.id, { onDelete: "cascade" }),
+    type: text("type").notNull(), // 'email', 'slack', 'whatsapp', 'phone', etc.
+    address: text("address").notNull(), // the actual identifier on that channel
+    isPrimary: integer("is_primary", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    externalUserId: text("external_user_id"), // channel-native user ID (e.g., Telegram numeric ID, E.164 phone)
+    externalChatId: text("external_chat_id"), // delivery/notification routing address (e.g., Telegram chat ID)
+    status: text("status").notNull().default("unverified"), // 'active' | 'pending' | 'revoked' | 'blocked' | 'unverified'
+    policy: text("policy").notNull().default("allow"), // 'allow' | 'deny' | 'escalate'
+    verifiedAt: integer("verified_at"), // epoch ms
+    verifiedVia: text("verified_via"), // 'challenge' | 'invite' | 'bootstrap' | etc.
+    inviteId: text("invite_id"), // reference to invite that onboarded
+    revokedReason: text("revoked_reason"),
+    blockedReason: text("blocked_reason"),
+    lastSeenAt: integer("last_seen_at"), // epoch ms
+    updatedAt: integer("updated_at"), // epoch ms
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_contact_channels_type_ext_user").on(
+      table.type,
+      table.externalUserId,
+    ),
+    index("idx_contact_channels_type_ext_chat").on(
+      table.type,
+      table.externalChatId,
+    ),
+  ],
+);
+
+export const assistantContactMetadata = sqliteTable(
+  "assistant_contact_metadata",
+  {
+    contactId: text("contact_id")
+      .primaryKey()
+      .references(() => contacts.id, { onDelete: "cascade" }),
+    species: text("species").notNull(), // 'vellum' | 'openclaw'
+    metadata: text("metadata"), // JSON blob for species-specific fields
+  },
+);
+
+export const assistantIngressInvites = sqliteTable(
+  "assistant_ingress_invites",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id")
+      .notNull()
+      .default(DAEMON_INTERNAL_ASSISTANT_ID),
+    sourceChannel: text("source_channel").notNull(),
+    tokenHash: text("token_hash").notNull(),
+    createdBySessionId: text("created_by_session_id"),
+    note: text("note"),
+    maxUses: integer("max_uses").notNull().default(1),
+    useCount: integer("use_count").notNull().default(0),
+    expiresAt: integer("expires_at").notNull(),
+    status: text("status").notNull().default("active"),
+    redeemedByExternalUserId: text("redeemed_by_external_user_id"),
+    redeemedByExternalChatId: text("redeemed_by_external_chat_id"),
+    redeemedAt: integer("redeemed_at"),
+    // Voice invite fields (nullable — non-voice invites leave these NULL)
+    expectedExternalUserId: text("expected_external_user_id"),
+    voiceCodeHash: text("voice_code_hash"),
+    voiceCodeDigits: integer("voice_code_digits"),
+    // Display metadata for personalized voice prompts (nullable — non-voice invites leave these NULL)
+    friendName: text("friend_name"),
+    guardianName: text("guardian_name"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const assistantInboxThreadState = sqliteTable(
+  "assistant_inbox_thread_state",
+  {
+    conversationId: text("conversation_id")
+      .primaryKey()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    assistantId: text("assistant_id")
+      .notNull()
+      .default(DAEMON_INTERNAL_ASSISTANT_ID),
+    sourceChannel: text("source_channel").notNull(),
+    externalChatId: text("external_chat_id").notNull(),
+    externalUserId: text("external_user_id"),
+    displayName: text("display_name"),
+    username: text("username"),
+    lastInboundAt: integer("last_inbound_at"),
+    lastOutboundAt: integer("last_outbound_at"),
+    lastMessageAt: integer("last_message_at"),
+    unreadCount: integer("unread_count").notNull().default(0),
+    pendingEscalationCount: integer("pending_escalation_count")
+      .notNull()
+      .default(0),
+    hasPendingEscalation: integer("has_pending_escalation")
+      .notNull()
+      .default(0),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);

package/src/memory/schema/conversations.ts

@@ -0,0 +1,129 @@
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+export const conversations = sqliteTable(
+  "conversations",
+  {
+    id: text("id").primaryKey(),
+    title: text("title"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    totalInputTokens: integer("total_input_tokens").notNull().default(0),
+    totalOutputTokens: integer("total_output_tokens").notNull().default(0),
+    totalEstimatedCost: real("total_estimated_cost").notNull().default(0),
+    contextSummary: text("context_summary"),
+    contextCompactedMessageCount: integer("context_compacted_message_count")
+      .notNull()
+      .default(0),
+    contextCompactedAt: integer("context_compacted_at"),
+    threadType: text("thread_type").notNull().default("standard"),
+    source: text("source").notNull().default("user"),
+    memoryScopeId: text("memory_scope_id").notNull().default("default"),
+    originChannel: text("origin_channel"),
+    originInterface: text("origin_interface"),
+    isAutoTitle: integer("is_auto_title").notNull().default(1),
+    scheduleJobId: text("schedule_job_id"),
+  },
+  (table) => [
+    index("idx_conversations_updated_at").on(table.updatedAt),
+    index("idx_conversations_thread_type").on(table.threadType),
+  ],
+);
+
+export const messages = sqliteTable(
+  "messages",
+  {
+    id: text("id").primaryKey(),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    role: text("role").notNull(),
+    content: text("content").notNull(),
+    createdAt: integer("created_at").notNull(),
+    metadata: text("metadata"),
+  },
+  (table) => [index("idx_messages_conversation_id").on(table.conversationId)],
+);
+
+export const toolInvocations = sqliteTable(
+  "tool_invocations",
+  {
+    id: text("id").primaryKey(),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id),
+    toolName: text("tool_name").notNull(),
+    input: text("input").notNull(),
+    result: text("result").notNull(),
+    decision: text("decision").notNull(),
+    riskLevel: text("risk_level").notNull(),
+    durationMs: integer("duration_ms").notNull(),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_tool_invocations_conversation_id").on(table.conversationId),
+  ],
+);
+
+export const conversationKeys = sqliteTable("conversation_keys", {
+  id: text("id").primaryKey(),
+  conversationKey: text("conversation_key").notNull(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const attachments = sqliteTable("attachments", {
+  id: text("id").primaryKey(),
+  originalFilename: text("original_filename").notNull(),
+  mimeType: text("mime_type").notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  kind: text("kind").notNull(),
+  dataBase64: text("data_base64").notNull(),
+  contentHash: text("content_hash"),
+  thumbnailBase64: text("thumbnail_base64"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const messageAttachments = sqliteTable("message_attachments", {
+  id: text("id").primaryKey(),
+  messageId: text("message_id")
+    .notNull()
+    .references(() => messages.id, { onDelete: "cascade" }),
+  attachmentId: text("attachment_id")
+    .notNull()
+    .references(() => attachments.id, { onDelete: "cascade" }),
+  position: integer("position").notNull().default(0),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const channelInboundEvents = sqliteTable("channel_inbound_events", {
+  id: text("id").primaryKey(),
+  sourceChannel: text("source_channel").notNull(),
+  externalChatId: text("external_chat_id").notNull(),
+  externalMessageId: text("external_message_id").notNull(),
+  sourceMessageId: text("source_message_id"),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  messageId: text("message_id").references(() => messages.id, {
+    onDelete: "cascade",
+  }),
+  deliveryStatus: text("delivery_status").notNull().default("pending"),
+  processingStatus: text("processing_status").notNull().default("pending"),
+  processingAttempts: integer("processing_attempts").notNull().default(0),
+  lastProcessingError: text("last_processing_error"),
+  retryAfter: integer("retry_after"),
+  rawPayload: text("raw_payload"),
+  deliveredSegmentCount: integer("delivered_segment_count")
+    .notNull()
+    .default(0),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});