@vellumai/assistant 0.4.31 → 0.4.32

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(),
+});

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(),
+  },
+);