@free-intelligence/core 1.1.0

package/src/agent/state.ts

@@ -0,0 +1,258 @@
+/**
+ * AgentTurnState — the reduced state the fi-glass agent panels render, plus the
+ * pure `applyAgentEvent` reducer that derives it from the wire stream.
+ *
+ * The reducer is pure (no React, no transport, no I/O) so every app reuses the
+ * same event→state logic and only supplies the transport that produces the
+ * AgentStreamEvent stream. Immutable: every event returns a new state object.
+ */
+
+import type {
+  AgentStreamEvent,
+  AgentMeta,
+  GuardRejection,
+  ToolCall,
+  StepStatus,
+} from './events';
+
+/** One step of the declared plan, enriched with live status. */
+export interface PlanStep {
+  label: string;
+  status: StepStatus;
+  summary?: string;
+  error?: string;
+  /** Free-text annotation from note_step (carried by the step_noted event). */
+  note?: string;
+}
+
+/** Terminal verdict of a whole plan (finalize_plan / cancel_plan). */
+export type PlanOutcome = 'completed' | 'failed' | 'cancelled';
+
+/** The agent's declared plan. Guard-as-quality: rejection is woven in here. */
+export interface AgentPlan {
+  steps: PlanStep[];
+  /** Set when a guard blocks; cleared when a fresh plan is declared. */
+  rejection?: GuardRejection | null;
+  /**
+   * Set when the agent restructures the plan mid-turn (plan_amended). 'replan'
+   * is then followed by a fresh `plan` event that reseeds steps and clears this.
+   */
+  amended?: 'insert' | 'replan' | null;
+  /** Terminal plan verdict once finalize_plan / cancel_plan settles it. */
+  outcome?: PlanOutcome | null;
+}
+
+export type AgentTurnStatus = 'thinking' | 'streaming' | 'done' | 'error';
+
+/** The full reduced state of one agentic turn. */
+export interface AgentTurnState {
+  plan: AgentPlan | null;
+  steps: ToolCall[];
+  text: string;
+  /** Evidence references (e.g. source URLs). App-agnostic name. */
+  sources: string[];
+  meta: AgentMeta | null;
+  status: AgentTurnStatus;
+  errorMessage?: string;
+}
+
+/** A fresh, empty turn — call at the start of each agentic turn. */
+export function initialAgentTurnState(): AgentTurnState {
+  return {
+    plan: null,
+    steps: [],
+    text: '',
+    sources: [],
+    meta: null,
+    status: 'thinking',
+  };
+}
+
+/**
+ * Pure reducer: apply one wire event to the turn state, returning a new state.
+ *
+ * Mirrors the universal turn lifecycle; an app's hook feeds it the events its
+ * transport produces. Unknown/transport-only events (`open`) pass through
+ * untouched.
+ */
+export function applyAgentEvent(
+  state: AgentTurnState,
+  event: AgentStreamEvent
+): AgentTurnState {
+  // Bump 'thinking' → 'streaming' on the first sign of activity; never regress
+  // a settled ('done'/'error') turn. Mirrors the original's status moves but is
+  // guarded against out-of-order events.
+  const streamingStatus: AgentTurnStatus =
+    state.status === 'thinking' ? 'streaming' : state.status;
+
+  switch (event.type) {
+    case 'open':
+      return state;
+
+    case 'plan':
+      // A fresh plan seeds N steps as 'pending' (index i ↔ step i) and clears
+      // any prior guard rejection (the agent is re-declaring).
+      return {
+        ...state,
+        plan: {
+          steps: event.steps.map((label) => ({ label, status: 'pending' })),
+          rejection: null,
+          amended: null,
+          outcome: null,
+        },
+        status: streamingStatus,
+      };
+
+    case 'plan_rejected':
+      return state.plan
+        ? { ...state, plan: { ...state.plan, rejection: event.rejection } }
+        : { ...state, plan: { steps: [], rejection: event.rejection } };
+
+    case 'step_started': {
+      if (!state.plan) return state;
+      const idx = event.index;
+      if (idx < 0 || idx >= state.plan.steps.length) return state; // bounds guard
+      // Catch-up sweep: starting step N implies steps 0..N-1 finished, even if
+      // their step_done events were dropped (SSE is lossy). Then mark N running.
+      const steps = state.plan.steps.map((s, i) => {
+        if (i < idx && (s.status === 'pending' || s.status === 'running')) {
+          return { ...s, status: 'done' as const };
+        }
+        if (i === idx) return { ...s, status: 'running' as const };
+        return s;
+      });
+      return { ...state, plan: { ...state.plan, steps } };
+    }
+
+    case 'step_done': {
+      if (!state.plan) return state;
+      const idx = event.index;
+      if (idx < 0 || idx >= state.plan.steps.length) return state; // bounds guard
+      const steps = state.plan.steps.map((s, i) => {
+        if (i !== idx) return s; // mutate exactly step N — no off-by-one
+        const patch: PlanStep = { ...s, status: event.status };
+        // 'done' carries a summary; 'failed'/'cancelled' carry a reason in error.
+        if (event.status === 'done') {
+          if (event.summary) patch.summary = event.summary;
+        } else if (event.error) {
+          patch.error = event.error;
+        }
+        return patch;
+      });
+      return { ...state, plan: { ...state.plan, steps } };
+    }
+
+    case 'step_noted': {
+      // Annotate exactly step N with a free-text note; never touches status.
+      if (!state.plan) return state;
+      const idx = event.index;
+      if (idx < 0 || idx >= state.plan.steps.length) return state; // bounds guard
+      const steps = state.plan.steps.map((s, i) =>
+        i === idx ? { ...s, note: event.note } : s
+      );
+      return { ...state, plan: { ...state.plan, steps } };
+    }
+
+    case 'plan_amended':
+      // Record that the plan was restructured. For 'replan' the new steps land
+      // in a following `plan` event (which clears this flag); here we only set
+      // the badge signal — the amended event carries no steps to apply.
+      return state.plan
+        ? { ...state, plan: { ...state.plan, amended: event.action } }
+        : state;
+
+    case 'plan_cancelled': {
+      // The whole plan was abandoned. Settle still-open steps as 'cancelled'
+      // (NOT 'done' — distinct from the `result` close-out sweep, which only
+      // touches pending/running and would wrongly mark these done if it ran
+      // after us). Already-settled steps keep their terminal status.
+      if (!state.plan) return state;
+      const steps = state.plan.steps.map((s) =>
+        s.status === 'pending' || s.status === 'running'
+          ? { ...s, status: 'cancelled' as const }
+          : s
+      );
+      return { ...state, plan: { ...state.plan, steps, outcome: 'cancelled' } };
+    }
+
+    case 'plan_completed':
+      // Terminal verdict. Per-step statuses already reflect reality (each
+      // step_done settled them); we only stamp the plan-level outcome. The
+      // wire counts are derivable from steps[].status, so we don't store them.
+      return state.plan
+        ? { ...state, plan: { ...state.plan, outcome: 'completed' } }
+        : state;
+
+    case 'plan_failed':
+      // Plan failed (>=1 step failed). Leave step statuses as settled — a
+      // failed plan can still have done steps — and stamp the outcome.
+      return state.plan
+        ? { ...state, plan: { ...state.plan, outcome: 'failed' } }
+        : state;
+
+    case 'tool_call': {
+      // Dedupe-on-arrival by id (DELIBERATE divergence from the original's
+      // append + replace-at-result, since the contract's `result` carries no
+      // tool_calls). id == null = still pending → append.
+      const existing =
+        event.call.id != null
+          ? state.steps.findIndex((c) => c.id === event.call.id)
+          : -1;
+      const steps =
+        existing >= 0
+          ? state.steps.map((c, i) => (i === existing ? event.call : c))
+          : [...state.steps, event.call];
+      return { ...state, steps, status: streamingStatus };
+    }
+
+    case 'text':
+      // CONCATENATE deltas (never replace) — the streaming bug that compiles
+      // identically but only shows the last fragment at runtime.
+      return {
+        ...state,
+        text: state.text + event.delta,
+        status: streamingStatus,
+      };
+
+    case 'result': {
+      // Never wipe a non-empty streamed accumulation with an empty result.text
+      // (the agent ran tools but composed no final response). Note: app-specific
+      // dedupe/source-extraction stays in the app's hook, which emits
+      // `sources` already extracted.
+      const text = event.text.trim() ? event.text : state.text;
+      // Close any plan steps left open when the turn settles.
+      const plan = state.plan
+        ? {
+            ...state.plan,
+            steps: state.plan.steps.map((s) =>
+              s.status === 'pending' || s.status === 'running'
+                ? { ...s, status: 'done' as const }
+                : s
+            ),
+          }
+        : state.plan;
+      return {
+        ...state,
+        text,
+        plan,
+        sources: event.sources ?? state.sources,
+        meta: event.meta ?? state.meta,
+        status: 'done',
+      };
+    }
+
+    case 'meta':
+      return { ...state, meta: event.meta };
+
+    case 'error':
+      return { ...state, status: 'error', errorMessage: event.message };
+
+    case 'done':
+      return state.status === 'thinking' || state.status === 'streaming'
+        ? { ...state, status: 'done' }
+        : state;
+
+    default:
+      return state;
+  }
+}

package/src/agent/transcript.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Tests for the transcript bridge — specifically that model provenance
+ * survives the fold (turn.meta.model → message.metadata.model) so a shell's
+ * badge slot has real data after persistence.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { foldAssistantTurn, makeUserMessage } from './transcript';
+import { initialAgentTurnState } from './state';
+import type { AgentTurnState } from './state';
+
+function turnWith(partial: Partial<AgentTurnState>): AgentTurnState {
+  return { ...initialAgentTurnState(), text: 'hola', ...partial };
+}
+
+describe('foldAssistantTurn — model provenance', () => {
+  it('persists turn.meta.model into metadata.model', () => {
+    const msg = foldAssistantTurn(
+      turnWith({ meta: { model: 'gpt-5.2-mini' } }),
+    );
+    expect(msg.role).toBe('assistant');
+    expect(msg.metadata).toEqual({ model: 'gpt-5.2-mini' });
+  });
+
+  it('omits metadata entirely when the turn has no model', () => {
+    expect(foldAssistantTurn(turnWith({ meta: null })).metadata).toBeUndefined();
+    expect(
+      foldAssistantTurn(turnWith({ meta: { latencyMs: 12 } })).metadata,
+    ).toBeUndefined();
+  });
+});
+
+describe('makeUserMessage', () => {
+  it('builds a user message with an ISO timestamp', () => {
+    const msg = makeUserMessage('hola');
+    expect(msg.role).toBe('user');
+    expect(Number.isNaN(new Date(msg.timestamp).getTime())).toBe(false);
+  });
+});

package/src/agent/transcript.ts

@@ -0,0 +1,36 @@
+/**
+ * Transcript bridge — fold the live agentic turn into flat chat messages.
+ *
+ * Pure, framework-agnostic (no React, no transport). The agent contract models
+ * ONE live turn (AgentTurnState); a conversation surface needs the thread as a
+ * flat list. These two helpers bridge `AgentTurnState` → `ChatMessage` so any
+ * shell (fi-glass and beyond) can keep a visible transcript without re-deriving
+ * the mapping. Moved here from the og118 consumer (DD-002-LESSON): a reusable
+ * primitive belongs in the framework, not the app wrapper.
+ */
+
+import type { ChatMessage } from '../chat/message';
+import type { AgentTurnState } from './state';
+
+/** A user message, ready to render optimistically the instant the user sends. */
+export function makeUserMessage(text: string): ChatMessage {
+  return { role: 'user', content: text, timestamp: new Date().toISOString() };
+}
+
+/**
+ * Fold a finished turn's answer into an assistant message. Keeps only the
+ * material-agnostic content (no AgentTurnState snapshot) — a future gate can add
+ * per-turn glass-box rendering without bloating the ChatMessage contract now.
+ * Model provenance survives the fold: `turn.meta.model` lands in
+ * `metadata.model` so a shell's badge slot ("Powered by …") has real data after
+ * persistence, not just during the live turn.
+ */
+export function foldAssistantTurn(turn: AgentTurnState): ChatMessage {
+  const model = turn.meta?.model;
+  return {
+    role: 'assistant',
+    content: turn.text,
+    timestamp: new Date().toISOString(),
+    ...(model ? { metadata: { model } } : {}),
+  };
+}

package/src/chat/hook.ts

@@ -0,0 +1,49 @@
+import type { ChatMessage, ChatStreamingState } from './message';
+
+/**
+ * ChatHook — the conversation contract the fi-glass shell consumes.
+ *
+ * This is the dependency-inversion spine of the chat shell: ChatWidget never
+ * imports a concrete conversation hook, it consumes this interface. aurity
+ * implements it with `useFIConversation`; og118 implements its own against its
+ * backend. A fat contract (state + actions + streaming) → it earns a place in
+ * core (unlike navigation, which is a plain callback prop).
+ *
+ * Generic over:
+ * - `TMessage` — the message type (aurity passes its FIMessage; default ChatMessage).
+ * - `TNode`    — the UI-slot node type (aurity passes React's ReactNode). Kept
+ *   generic so core stays framework-agnostic (no React import).
+ */
+export interface ChatHook<TMessage = ChatMessage, TNode = unknown> {
+  // ---- State ----
+  messages: TMessage[];
+  loading: boolean;
+  isTyping: boolean;
+  loadingInitial?: boolean;
+  hasMoreMessages?: boolean;
+  loadingOlder?: boolean;
+  streamingMessage?: string;
+  streaming?: ChatStreamingState;
+
+  // ---- Core actions ----
+  sendMessage: (message: string, metadata?: object) => Promise<void>;
+  sendMessageStream?: (message: string, metadata?: object) => Promise<void>;
+  loadOlderMessages?: () => Promise<void>;
+
+  // ---- Optional actions ----
+  clearConversation?: () => void;
+  getIntroduction?: () => void;
+  startConversation?: () => Promise<void>;
+  sendQuickReply?: (reply: string) => Promise<void>;
+
+  // ---- Optional state ----
+  conversationState?: {
+    quickReplies?: string[];
+    actions?: Array<{ type: string; data: unknown }>;
+    metadata?: Record<string, unknown>;
+  };
+
+  // ---- Custom UI slots (typed by the consumer's node type) ----
+  customEmptyState?: TNode;
+  customQuickReplies?: TNode;
+}

package/src/chat/message.ts

@@ -0,0 +1,36 @@
+/**
+ * ChatMessage — the material-agnostic shape of one chat message.
+ *
+ * Apps may use a richer message type (e.g. aurity's FIMessage with typed
+ * metadata); ChatHook is generic over the message type and defaults to this.
+ * Pure data — no React, no styling.
+ */
+export interface ChatMessage {
+  /** Stable id (optional for transient/streaming messages). */
+  id?: string;
+  /** Who authored the message. */
+  role: 'user' | 'assistant';
+  /** The message text. */
+  content: string;
+  /** Optional model reasoning rendered before the content. */
+  thinking?: string | null;
+  /** ISO 8601 timestamp. */
+  timestamp: string;
+  /** App-specific metadata (tone, voice, model, …). */
+  metadata?: Record<string, unknown>;
+}
+
+/** Streaming state surfaced by a ChatHook while a response is in flight. */
+export interface ChatStreamingState {
+  status:
+    | 'idle'
+    | 'connecting'
+    | 'streaming'
+    | 'thinking'
+    | 'complete'
+    | 'error'
+    | 'aborted';
+  content: string;
+  thinking: string;
+  isStreaming: boolean;
+}

package/src/conversation/helpers.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Unit tests for the conversation helpers (DD-002B1.1). These are pure,
+ * deterministic functions; the tests pin the two things that matter most for a
+ * substrate consumed by multiple apps: privacy-by-structure (sanitize drops
+ * everything but role/content/timestamp) and deterministic derivation
+ * (title/preview/record are reproducible given a fixed `now`).
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { ChatMessage } from '../chat/message';
+import {
+  CONVERSATION_SCHEMA_VERSION,
+  createConversationRecord,
+  summarizeConversation,
+  deriveConversationTitle,
+  deriveConversationPreview,
+  sanitizeConversationMessage,
+} from './helpers';
+
+const NOW = '2026-06-09T00:00:00.000Z';
+
+function msg(
+  role: 'user' | 'assistant',
+  content: string,
+  extra: Partial<ChatMessage> = {},
+): ChatMessage {
+  return { role, content, timestamp: '2026-06-09T00:00:01.000Z', ...extra };
+}
+
+describe('sanitizeConversationMessage — privacy by structure', () => {
+  it('keeps only role, content, timestamp', () => {
+    const dirty: ChatMessage = {
+      role: 'assistant',
+      content: 'hola',
+      timestamp: NOW,
+      id: 'abc123',
+      thinking: 'secret chain of thought',
+      metadata: { token: 'Bearer xyz', tool: { payload: 'danger' } },
+    };
+    const clean = sanitizeConversationMessage(dirty);
+    expect(clean).toEqual({ role: 'assistant', content: 'hola', timestamp: NOW });
+    expect('id' in clean).toBe(false);
+    expect('thinking' in clean).toBe(false);
+    expect('metadata' in clean).toBe(false);
+  });
+
+  it('drops unknown future fields by construction', () => {
+    const future = {
+      role: 'user',
+      content: 'x',
+      timestamp: NOW,
+      futureSecret: 'should not survive',
+    } as unknown as ChatMessage;
+    const clean = sanitizeConversationMessage(future);
+    expect(Object.keys(clean).sort()).toEqual(['content', 'role', 'timestamp']);
+  });
+});
+
+describe('deriveConversationTitle', () => {
+  it('uses the first non-empty user message, skipping assistant + empty', () => {
+    const title = deriveConversationTitle([
+      msg('assistant', 'intro screen'),
+      msg('user', '   '),
+      msg('user', 'How do I deploy og118?'),
+      msg('user', 'second question'),
+    ]);
+    expect(title).toBe('How do I deploy og118?');
+  });
+
+  it('falls back to "New chat" with no usable user message', () => {
+    expect(deriveConversationTitle([])).toBe('New chat');
+    expect(deriveConversationTitle([msg('assistant', 'only assistant')])).toBe(
+      'New chat',
+    );
+  });
+
+  it('truncates deterministically with an ellipsis', () => {
+    const long = 'a'.repeat(100);
+    const title = deriveConversationTitle([msg('user', long)], 10);
+    expect(title).toBe(`${'a'.repeat(9)}…`);
+    expect(title.length).toBe(10);
+  });
+});
+
+describe('deriveConversationPreview', () => {
+  it('uses the last non-empty message of any role', () => {
+    const preview = deriveConversationPreview([
+      msg('user', 'first'),
+      msg('assistant', 'last real answer'),
+      msg('assistant', '   '),
+    ]);
+    expect(preview).toBe('last real answer');
+  });
+
+  it('returns empty string when nothing has content', () => {
+    expect(deriveConversationPreview([])).toBe('');
+    expect(deriveConversationPreview([msg('user', '  ')])).toBe('');
+  });
+});
+
+describe('createConversationRecord', () => {
+  it('stamps a deterministic now and the schema version', () => {
+    const rec = createConversationRecord({
+      id: 'sess-1',
+      messages: [msg('user', 'hello there')],
+      now: NOW,
+    });
+    expect(rec.id).toBe('sess-1');
+    expect(rec.createdAt).toBe(NOW);
+    expect(rec.updatedAt).toBe(NOW);
+    expect(rec.schemaVersion).toBe(CONVERSATION_SCHEMA_VERSION);
+    expect(rec.title).toBe('hello there');
+    expect(rec.preview).toBe('hello there');
+  });
+
+  it('sanitizes the seeded messages', () => {
+    const rec = createConversationRecord({
+      id: 'sess-2',
+      messages: [msg('user', 'hi', { metadata: { token: 'Bearer secret' } })],
+      now: NOW,
+    });
+    expect(rec.messages[0]).toEqual({
+      role: 'user',
+      content: 'hi',
+      timestamp: '2026-06-09T00:00:01.000Z',
+    });
+  });
+
+  it('defaults to an empty thread', () => {
+    const rec = createConversationRecord({ id: 'sess-3', now: NOW });
+    expect(rec.messages).toEqual([]);
+    expect(rec.title).toBe('New chat');
+    expect(rec.preview).toBe('');
+  });
+});
+
+describe('summarizeConversation', () => {
+  it('excludes the messages array', () => {
+    const rec = createConversationRecord({
+      id: 'sess-4',
+      messages: [msg('user', 'q'), msg('assistant', 'a')],
+      now: NOW,
+    });
+    const summary = summarizeConversation(rec);
+    expect('messages' in summary).toBe(false);
+    expect(summary).toEqual({
+      id: 'sess-4',
+      title: 'q',
+      createdAt: NOW,
+      updatedAt: NOW,
+      preview: 'a',
+    });
+  });
+});

package/src/conversation/helpers.ts

@@ -0,0 +1,109 @@
+/**
+ * Conversation helpers — pure, deterministic primitives for building and
+ * summarizing ConversationRecords. No React, no browser, no transport.
+ *
+ * Privacy by structure: `sanitizeConversationMessage` builds a NEW message with
+ * exactly the allowed subset (role / content / timestamp). Any other field a
+ * ChatMessage may carry now or later — `id`, `thinking`, `metadata`, a future
+ * tool payload or token — is dropped by construction, not by an allow/deny list
+ * someone must remember to update. The initial privacy guarantee is the
+ * restriction, not PII heuristics.
+ *
+ * Determinism: helpers that stamp a time accept an optional `now` so tests are
+ * reproducible; they fall back to the wall clock only when it is omitted.
+ */
+
+import type { ChatMessage } from '../chat/message';
+import type { ConversationRecord, ConversationSummary } from './record';
+
+/** Schema version stamped on every record created here. */
+export const CONVERSATION_SCHEMA_VERSION = 1;
+
+/** Fallback title when there is no usable user message yet. */
+const DEFAULT_TITLE = 'New chat';
+const TITLE_MAX = 60;
+const PREVIEW_MAX = 120;
+
+/** Collapse whitespace and truncate to `max` chars with an ellipsis. Pure. */
+function truncate(text: string, max: number): string {
+  const t = text.trim().replace(/\s+/g, ' ');
+  if (t.length <= max) return t;
+  return `${t.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+
+/**
+ * Reduce a ChatMessage to the only fields safe to persist: role, content, and
+ * timestamp. Drops id, thinking, metadata, and anything else by construction.
+ */
+export function sanitizeConversationMessage(message: ChatMessage): ChatMessage {
+  return {
+    role: message.role,
+    content: message.content,
+    timestamp: message.timestamp,
+  };
+}
+
+/** Title from the first non-empty user message; `DEFAULT_TITLE` otherwise. */
+export function deriveConversationTitle(
+  messages: ChatMessage[],
+  max: number = TITLE_MAX,
+): string {
+  const firstUser = messages.find(
+    (m) => m.role === 'user' && m.content.trim() !== '',
+  );
+  if (!firstUser) return DEFAULT_TITLE;
+  return truncate(firstUser.content, max) || DEFAULT_TITLE;
+}
+
+/** Preview from the last non-empty message of any role; `''` otherwise. */
+export function deriveConversationPreview(
+  messages: ChatMessage[],
+  max: number = PREVIEW_MAX,
+): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].content.trim() !== '') {
+      return truncate(messages[i].content, max);
+    }
+  }
+  return '';
+}
+
+/** Arguments for {@link createConversationRecord}. */
+export interface CreateConversationRecordArgs {
+  /** Stable id (doubles as the backend session_id). */
+  id: string;
+  /** Initial thread; sanitized before storing. Default: empty. */
+  messages?: ChatMessage[];
+  /** ISO timestamp to stamp createdAt/updatedAt. Default: now. */
+  now?: string;
+}
+
+/** Build a fresh, sanitized record with derived title + preview. */
+export function createConversationRecord(
+  args: CreateConversationRecordArgs,
+): ConversationRecord {
+  const now = args.now ?? new Date().toISOString();
+  const messages = (args.messages ?? []).map(sanitizeConversationMessage);
+  return {
+    id: args.id,
+    title: deriveConversationTitle(messages),
+    createdAt: now,
+    updatedAt: now,
+    messages,
+    preview: deriveConversationPreview(messages),
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+  };
+}
+
+/** Project a record to its light summary — excludes `messages`. */
+export function summarizeConversation(
+  record: ConversationRecord,
+): ConversationSummary {
+  return {
+    id: record.id,
+    title: record.title,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    preview: record.preview,
+  };
+}