@vellumai/assistant 0.4.30 → 0.4.32

package/src/memory/schema/guardian.ts

@@ -0,0 +1,172 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
+import { callPendingQuestions, callSessions } from "./calls.js";
+
+export const guardianActionRequests = sqliteTable(
+  "guardian_action_requests",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id")
+      .notNull()
+      .default(DAEMON_INTERNAL_ASSISTANT_ID),
+    kind: text("kind").notNull(), // 'ask_guardian'
+    sourceChannel: text("source_channel").notNull(), // 'voice'
+    sourceConversationId: text("source_conversation_id").notNull(),
+    callSessionId: text("call_session_id")
+      .notNull()
+      .references(() => callSessions.id, { onDelete: "cascade" }),
+    pendingQuestionId: text("pending_question_id")
+      .notNull()
+      .references(() => callPendingQuestions.id, { onDelete: "cascade" }),
+    questionText: text("question_text").notNull(),
+    requestCode: text("request_code").notNull(), // short human-readable code for routing replies
+    status: text("status").notNull().default("pending"), // pending | answered | expired | cancelled
+    answerText: text("answer_text"),
+    answeredByChannel: text("answered_by_channel"),
+    answeredByExternalUserId: text("answered_by_external_user_id"),
+    answeredAt: integer("answered_at"),
+    expiresAt: integer("expires_at").notNull(),
+    expiredReason: text("expired_reason"), // call_timeout | sweep_timeout | cancelled
+    followupState: text("followup_state").notNull().default("none"), // none | awaiting_guardian_choice | dispatching | completed | declined | failed
+    lateAnswerText: text("late_answer_text"),
+    lateAnsweredAt: integer("late_answered_at"),
+    followupAction: text("followup_action"), // call_back | message_back | decline
+    followupCompletedAt: integer("followup_completed_at"),
+    toolName: text("tool_name"), // tool identity for tool-approval requests
+    inputDigest: text("input_digest"), // canonical SHA-256 digest of tool input
+    supersededByRequestId: text("superseded_by_request_id"), // links to the request that replaced this one
+    supersededAt: integer("superseded_at"), // epoch ms when supersession occurred
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_guardian_action_requests_session_status_created").on(
+      table.callSessionId,
+      table.status,
+      table.createdAt,
+    ),
+  ],
+);
+
+export const guardianActionDeliveries = sqliteTable(
+  "guardian_action_deliveries",
+  {
+    id: text("id").primaryKey(),
+    requestId: text("request_id")
+      .notNull()
+      .references(() => guardianActionRequests.id, { onDelete: "cascade" }),
+    destinationChannel: text("destination_channel").notNull(), // 'telegram' | 'sms' | 'vellum'
+    destinationConversationId: text("destination_conversation_id"),
+    destinationChatId: text("destination_chat_id"),
+    destinationExternalUserId: text("destination_external_user_id"),
+    status: text("status").notNull().default("pending"), // pending | sent | failed | answered | expired | cancelled
+    sentAt: integer("sent_at"),
+    respondedAt: integer("responded_at"),
+    lastError: text("last_error"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_guardian_action_deliveries_dest_conversation").on(
+      table.destinationConversationId,
+    ),
+  ],
+);
+
+export const canonicalGuardianRequests = sqliteTable(
+  "canonical_guardian_requests",
+  {
+    id: text("id").primaryKey(),
+    kind: text("kind").notNull(),
+    sourceType: text("source_type").notNull(),
+    sourceChannel: text("source_channel"),
+    conversationId: text("conversation_id"),
+    requesterExternalUserId: text("requester_external_user_id"),
+    requesterChatId: text("requester_chat_id"),
+    guardianExternalUserId: text("guardian_external_user_id"),
+    guardianPrincipalId: text("guardian_principal_id"),
+    callSessionId: text("call_session_id"),
+    pendingQuestionId: text("pending_question_id"),
+    questionText: text("question_text"),
+    requestCode: text("request_code"),
+    toolName: text("tool_name"),
+    inputDigest: text("input_digest"),
+    status: text("status").notNull().default("pending"),
+    answerText: text("answer_text"),
+    decidedByExternalUserId: text("decided_by_external_user_id"),
+    decidedByPrincipalId: text("decided_by_principal_id"),
+    followupState: text("followup_state"),
+    expiresAt: text("expires_at"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_canonical_guardian_requests_status").on(table.status),
+    index("idx_canonical_guardian_requests_guardian").on(
+      table.guardianExternalUserId,
+      table.status,
+    ),
+    index("idx_canonical_guardian_requests_conversation").on(
+      table.conversationId,
+      table.status,
+    ),
+    index("idx_canonical_guardian_requests_source").on(
+      table.sourceType,
+      table.status,
+    ),
+    index("idx_canonical_guardian_requests_kind").on(table.kind, table.status),
+    index("idx_canonical_guardian_requests_request_code").on(table.requestCode),
+  ],
+);
+
+export const canonicalGuardianDeliveries = sqliteTable(
+  "canonical_guardian_deliveries",
+  {
+    id: text("id").primaryKey(),
+    requestId: text("request_id")
+      .notNull()
+      .references(() => canonicalGuardianRequests.id, { onDelete: "cascade" }),
+    destinationChannel: text("destination_channel").notNull(),
+    destinationConversationId: text("destination_conversation_id"),
+    destinationChatId: text("destination_chat_id"),
+    destinationMessageId: text("destination_message_id"),
+    status: text("status").notNull().default("pending"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_canonical_guardian_deliveries_request_id").on(table.requestId),
+    index("idx_canonical_guardian_deliveries_status").on(table.status),
+  ],
+);
+
+export const scopedApprovalGrants = sqliteTable(
+  "scoped_approval_grants",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id").notNull(),
+    scopeMode: text("scope_mode").notNull(), // 'request_id' | 'tool_signature'
+    requestId: text("request_id"),
+    toolName: text("tool_name"),
+    inputDigest: text("input_digest"),
+    requestChannel: text("request_channel").notNull(),
+    decisionChannel: text("decision_channel").notNull(),
+    executionChannel: text("execution_channel"), // null = any channel
+    conversationId: text("conversation_id"),
+    callSessionId: text("call_session_id"),
+    requesterExternalUserId: text("requester_external_user_id"),
+    guardianExternalUserId: text("guardian_external_user_id"),
+    status: text("status").notNull(), // 'active' | 'consumed' | 'expired' | 'revoked'
+    expiresAt: text("expires_at").notNull(),
+    consumedAt: text("consumed_at"),
+    consumedByRequestId: text("consumed_by_request_id"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_scoped_grants_request_id").on(table.requestId),
+    index("idx_scoped_grants_tool_sig").on(table.toolName, table.inputDigest),
+    index("idx_scoped_grants_status_expires").on(table.status, table.expiresAt),
+  ],
+);

package/src/memory/schema/index.ts

@@ -0,0 +1,8 @@
+export * from "./calls.js";
+export * from "./contacts.js";
+export * from "./conversations.js";
+export * from "./guardian.js";
+export * from "./infrastructure.js";
+export * from "./memory-core.js";
+export * from "./notifications.js";
+export * from "./tasks.js";

package/src/memory/schema/infrastructure.ts

@@ -0,0 +1,205 @@
+import {
+  blob,
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+export const accounts = sqliteTable("accounts", {
+  id: text("id").primaryKey(),
+  service: text("service").notNull(),
+  username: text("username"),
+  email: text("email"),
+  displayName: text("display_name"),
+  status: text("status").notNull().default("active"),
+  credentialRef: text("credential_ref"),
+  metadataJson: text("metadata_json"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const reminders = sqliteTable("reminders", {
+  id: text("id").primaryKey(),
+  label: text("label").notNull(),
+  message: text("message").notNull(),
+  fireAt: integer("fire_at").notNull(), // epoch ms, absolute timestamp
+  mode: text("mode").notNull(), // 'notify' | 'execute'
+  status: text("status").notNull(), // 'pending' | 'firing' | 'fired' | 'cancelled'
+  firedAt: integer("fired_at"),
+  conversationId: text("conversation_id"),
+  routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
+  routingHintsJson: text("routing_hints_json").notNull().default("{}"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const cronJobs = sqliteTable("cron_jobs", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  cronExpression: text("cron_expression").notNull(), // e.g. '0 9 * * 1-5'
+  scheduleSyntax: text("schedule_syntax").notNull().default("cron"), // 'cron' | 'rrule'
+  timezone: text("timezone"), // e.g. 'America/Los_Angeles'
+  message: text("message").notNull(),
+  nextRunAt: integer("next_run_at").notNull(),
+  lastRunAt: integer("last_run_at"),
+  lastStatus: text("last_status"), // 'ok' | 'error'
+  retryCount: integer("retry_count").notNull().default(0),
+  createdBy: text("created_by").notNull(), // 'agent' | 'user'
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const cronRuns = sqliteTable("cron_runs", {
+  id: text("id").primaryKey(),
+  jobId: text("job_id")
+    .notNull()
+    .references(() => cronJobs.id, { onDelete: "cascade" }),
+  status: text("status").notNull(), // 'ok' | 'error'
+  startedAt: integer("started_at").notNull(),
+  finishedAt: integer("finished_at"),
+  durationMs: integer("duration_ms"),
+  output: text("output"),
+  error: text("error"),
+  conversationId: text("conversation_id"),
+  createdAt: integer("created_at").notNull(),
+});
+
+// Recurrence-centric aliases — prefer these in new code.
+// Physical table names remain `cron_jobs` / `cron_runs` for migration compatibility.
+export const scheduleJobs = cronJobs;
+export const scheduleRuns = cronRuns;
+
+export const sharedAppLinks = sqliteTable("shared_app_links", {
+  id: text("id").primaryKey(),
+  shareToken: text("share_token").notNull().unique(),
+  bundleData: blob("bundle_data", { mode: "buffer" }).notNull(),
+  bundleSizeBytes: integer("bundle_size_bytes").notNull(),
+  manifestJson: text("manifest_json").notNull(),
+  downloadCount: integer("download_count").notNull().default(0),
+  createdAt: integer("created_at").notNull(),
+  expiresAt: integer("expires_at"),
+});
+
+export const homeBaseAppLinks = sqliteTable("home_base_app_links", {
+  id: text("id").primaryKey(),
+  appId: text("app_id").notNull(),
+  source: text("source").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const publishedPages = sqliteTable("published_pages", {
+  id: text("id").primaryKey(),
+  deploymentId: text("deployment_id").notNull().unique(),
+  publicUrl: text("public_url").notNull(),
+  pageTitle: text("page_title"),
+  htmlHash: text("html_hash").notNull(),
+  publishedAt: integer("published_at").notNull(),
+  status: text("status").notNull().default("active"),
+  appId: text("app_id"),
+  projectSlug: text("project_slug"),
+});
+
+export const watchers = sqliteTable("watchers", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  providerId: text("provider_id").notNull(),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  pollIntervalMs: integer("poll_interval_ms").notNull().default(60000),
+  actionPrompt: text("action_prompt").notNull(),
+  watermark: text("watermark"),
+  conversationId: text("conversation_id"),
+  status: text("status").notNull().default("idle"), // idle | polling | error | disabled
+  consecutiveErrors: integer("consecutive_errors").notNull().default(0),
+  lastError: text("last_error"),
+  lastPollAt: integer("last_poll_at"),
+  nextPollAt: integer("next_poll_at").notNull(),
+  configJson: text("config_json"),
+  credentialService: text("credential_service").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const watcherEvents = sqliteTable("watcher_events", {
+  id: text("id").primaryKey(),
+  watcherId: text("watcher_id")
+    .notNull()
+    .references(() => watchers.id, { onDelete: "cascade" }),
+  externalId: text("external_id").notNull(),
+  eventType: text("event_type").notNull(),
+  summary: text("summary").notNull(),
+  payloadJson: text("payload_json").notNull(),
+  disposition: text("disposition").notNull().default("pending"), // pending | silent | notify | escalate | error
+  llmAction: text("llm_action"),
+  processedAt: integer("processed_at"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const llmRequestLogs = sqliteTable("llm_request_logs", {
+  id: text("id").primaryKey(),
+  conversationId: text("conversation_id").notNull(),
+  requestPayload: text("request_payload").notNull(),
+  responsePayload: text("response_payload").notNull(),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const llmUsageEvents = sqliteTable(
+  "llm_usage_events",
+  {
+    id: text("id").primaryKey(),
+    createdAt: integer("created_at").notNull(),
+    conversationId: text("conversation_id"),
+    runId: text("run_id"),
+    requestId: text("request_id"),
+    actor: text("actor").notNull(),
+    provider: text("provider").notNull(),
+    model: text("model").notNull(),
+    inputTokens: integer("input_tokens").notNull(),
+    outputTokens: integer("output_tokens").notNull(),
+    cacheCreationInputTokens: integer("cache_creation_input_tokens"),
+    cacheReadInputTokens: integer("cache_read_input_tokens"),
+    estimatedCostUsd: real("estimated_cost_usd"),
+    pricingStatus: text("pricing_status").notNull(),
+    metadataJson: text("metadata_json"),
+  },
+  (table) => [
+    index("idx_llm_usage_events_conversation_id").on(table.conversationId),
+  ],
+);
+
+export const actorTokenRecords = sqliteTable("actor_token_records", {
+  id: text("id").primaryKey(),
+  tokenHash: text("token_hash").notNull(),
+  assistantId: text("assistant_id").notNull(),
+  guardianPrincipalId: text("guardian_principal_id").notNull(),
+  hashedDeviceId: text("hashed_device_id").notNull(),
+  platform: text("platform").notNull(),
+  status: text("status").notNull().default("active"),
+  issuedAt: integer("issued_at").notNull(),
+  expiresAt: integer("expires_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const actorRefreshTokenRecords = sqliteTable(
+  "actor_refresh_token_records",
+  {
+    id: text("id").primaryKey(),
+    tokenHash: text("token_hash").notNull(),
+    familyId: text("family_id").notNull(),
+    assistantId: text("assistant_id").notNull(),
+    guardianPrincipalId: text("guardian_principal_id").notNull(),
+    hashedDeviceId: text("hashed_device_id").notNull(),
+    platform: text("platform").notNull(),
+    status: text("status").notNull().default("active"),
+    issuedAt: integer("issued_at").notNull(),
+    absoluteExpiresAt: integer("absolute_expires_at").notNull(),
+    inactivityExpiresAt: integer("inactivity_expires_at").notNull(),
+    lastUsedAt: integer("last_used_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);

package/src/memory/schema/memory-core.ts

@@ -0,0 +1,196 @@
+import {
+  blob,
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+  uniqueIndex,
+} from "drizzle-orm/sqlite-core";
+
+import { conversations, messages } from "./conversations.js";
+
+export const memorySegments = sqliteTable(
+  "memory_segments",
+  {
+    id: text("id").primaryKey(),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    conversationId: text("conversation_id")
+      .notNull()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    role: text("role").notNull(),
+    segmentIndex: integer("segment_index").notNull(),
+    text: text("text").notNull(),
+    tokenEstimate: integer("token_estimate").notNull(),
+    scopeId: text("scope_id").notNull().default("default"),
+    contentHash: text("content_hash"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [index("idx_memory_segments_scope_id").on(table.scopeId)],
+);
+
+export const memoryItems = sqliteTable(
+  "memory_items",
+  {
+    id: text("id").primaryKey(),
+    kind: text("kind").notNull(),
+    subject: text("subject").notNull(),
+    statement: text("statement").notNull(),
+    status: text("status").notNull(),
+    confidence: real("confidence").notNull(),
+    importance: real("importance"),
+    accessCount: integer("access_count").notNull().default(0),
+    fingerprint: text("fingerprint").notNull(),
+    verificationState: text("verification_state")
+      .notNull()
+      .default("assistant_inferred"),
+    scopeId: text("scope_id").notNull().default("default"),
+    firstSeenAt: integer("first_seen_at").notNull(),
+    lastSeenAt: integer("last_seen_at").notNull(),
+    lastUsedAt: integer("last_used_at"),
+    validFrom: integer("valid_from"),
+    invalidAt: integer("invalid_at"),
+  },
+  (table) => [
+    index("idx_memory_items_scope_id").on(table.scopeId),
+    index("idx_memory_items_fingerprint").on(table.fingerprint),
+  ],
+);
+
+export const memoryItemSources = sqliteTable(
+  "memory_item_sources",
+  {
+    memoryItemId: text("memory_item_id")
+      .notNull()
+      .references(() => memoryItems.id, { onDelete: "cascade" }),
+    messageId: text("message_id")
+      .notNull()
+      .references(() => messages.id, { onDelete: "cascade" }),
+    evidence: text("evidence"),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_memory_item_sources_memory_item_id").on(table.memoryItemId),
+  ],
+);
+
+export const memoryItemConflicts = sqliteTable(
+  "memory_item_conflicts",
+  {
+    id: text("id").primaryKey(),
+    scopeId: text("scope_id").notNull().default("default"),
+    existingItemId: text("existing_item_id")
+      .notNull()
+      .references(() => memoryItems.id, { onDelete: "cascade" }),
+    candidateItemId: text("candidate_item_id")
+      .notNull()
+      .references(() => memoryItems.id, { onDelete: "cascade" }),
+    relationship: text("relationship").notNull(),
+    status: text("status").notNull(),
+    clarificationQuestion: text("clarification_question"),
+    resolutionNote: text("resolution_note"),
+    lastAskedAt: integer("last_asked_at"),
+    resolvedAt: integer("resolved_at"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [index("idx_memory_item_conflicts_scope_id").on(table.scopeId)],
+);
+
+export const memorySummaries = sqliteTable(
+  "memory_summaries",
+  {
+    id: text("id").primaryKey(),
+    scope: text("scope").notNull(),
+    scopeKey: text("scope_key").notNull(),
+    summary: text("summary").notNull(),
+    tokenEstimate: integer("token_estimate").notNull(),
+    version: integer("version").notNull().default(1),
+    scopeId: text("scope_id").notNull().default("default"),
+    startAt: integer("start_at").notNull(),
+    endAt: integer("end_at").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_memory_summaries_scope_id").on(table.scopeId),
+    uniqueIndex("idx_memory_summaries_scope_scope_key").on(
+      table.scope,
+      table.scopeKey,
+    ),
+  ],
+);
+
+export const memoryEmbeddings = sqliteTable(
+  "memory_embeddings",
+  {
+    id: text("id").primaryKey(),
+    targetType: text("target_type").notNull(),
+    targetId: text("target_id").notNull(),
+    provider: text("provider").notNull(),
+    model: text("model").notNull(),
+    dimensions: integer("dimensions").notNull(),
+    vectorJson: text("vector_json"),
+    vectorBlob: blob("vector_blob"),
+    contentHash: text("content_hash"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("idx_memory_embeddings_target_provider_model").on(
+      table.targetType,
+      table.targetId,
+      table.provider,
+      table.model,
+    ),
+  ],
+);
+
+export const memoryJobs = sqliteTable("memory_jobs", {
+  id: text("id").primaryKey(),
+  type: text("type").notNull(),
+  payload: text("payload").notNull(),
+  status: text("status").notNull(),
+  attempts: integer("attempts").notNull().default(0),
+  deferrals: integer("deferrals").notNull().default(0),
+  runAfter: integer("run_after").notNull(),
+  lastError: text("last_error"),
+  startedAt: integer("started_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const memoryCheckpoints = sqliteTable("memory_checkpoints", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const memoryEntities = sqliteTable("memory_entities", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  aliases: text("aliases"),
+  description: text("description"),
+  firstSeenAt: integer("first_seen_at").notNull(),
+  lastSeenAt: integer("last_seen_at").notNull(),
+  mentionCount: integer("mention_count").notNull().default(1),
+});
+
+export const memoryEntityRelations = sqliteTable("memory_entity_relations", {
+  id: text("id").primaryKey(),
+  sourceEntityId: text("source_entity_id").notNull(),
+  targetEntityId: text("target_entity_id").notNull(),
+  relation: text("relation").notNull(),
+  evidence: text("evidence"),
+  firstSeenAt: integer("first_seen_at").notNull(),
+  lastSeenAt: integer("last_seen_at").notNull(),
+});
+
+export const memoryItemEntities = sqliteTable("memory_item_entities", {
+  memoryItemId: text("memory_item_id").notNull(),
+  entityId: text("entity_id").notNull(),
+});