@illuma-ai/agents 1.1.25 → 1.3.0

package/src/memory/pgvectorStore.ts

@@ -0,0 +1,324 @@
+/**
+ * Postgres + pgvector implementation of {@link MemoryBackend}.
+ *
+ * ## Scoping model (two-tier, layered)
+ *
+ * Every read query applies the layered filter
+ *
+ *   WHERE agent_id = $1 AND (user_id IS NULL OR user_id = $2)
+ *
+ * so the caller sees:
+ *   - agent-tier rows (`user_id IS NULL`) — shared operational knowledge,
+ *     visible to every user of the agent
+ *   - their own user-tier rows (`user_id = <caller>`) — private per-user
+ *     personalization
+ *
+ * Another user's user-tier rows are invisible — the privacy boundary is
+ * enforced in SQL, not just in the UI or route layer.
+ *
+ * ## Writes
+ *
+ * `append()` routes to a row based on the path's tier, resolved via
+ * {@link assertWritablePath}:
+ *
+ *   - `memory/agent/*` → stored with `user_id = NULL` regardless of
+ *     what scope the caller passed. Agent-tier content is inherently
+ *     shared; scoping it per-user would defeat the point.
+ *   - `memory/user/*`  → stored with `user_id = scope.userId`. A missing
+ *     `scope.userId` throws — user-tier paths cannot be written from
+ *     isolated/autonomous contexts.
+ *
+ * UPSERT key is `(agent_id, user_id, path)` with `NULLS NOT DISTINCT`,
+ * so each user gets their own `user/preferences.md` row and there is
+ * exactly one `agent/playbook.md` row shared across the whole user base.
+ * Content accumulates via `\n\n` concatenation on conflict, with the
+ * embedding regenerated over the merged content so search stays
+ * consistent.
+ */
+import type { Pool } from 'pg';
+import {
+  DEFAULT_MAX_SEARCH_RESULTS,
+  DEFAULT_MEMORY_TABLE,
+  DEFAULT_MIN_SCORE,
+  HYBRID_TEXT_WEIGHT,
+  HYBRID_VECTOR_WEIGHT,
+} from './constants';
+import { getMemoryEmbedder, type EmbeddingProvider } from './embeddings';
+import { applyMMRToMemoryHits } from './mmr';
+import { applyTemporalDecayToHits } from './temporalDecay';
+import { decorateCitations, shouldIncludeCitations } from './citations';
+import { assertWritablePath, getTierForPath } from './paths';
+import type {
+  MemoryAppendInput,
+  MemoryBackend,
+  MemoryEntry,
+  MemoryGetOptions,
+  MemoryHealth,
+  MemoryReadResult,
+  MemoryScope,
+  MemorySearchOptions,
+} from './types';
+
+export interface PgvectorStoreOptions {
+  pool: Pool;
+  table?: string;
+  embedder?: EmbeddingProvider;
+}
+
+function assertScope(scope: MemoryScope): void {
+  if (!scope || !scope.agentId) {
+    throw new Error(
+      'MemoryScope { agentId } is required — agentId must be non-empty'
+    );
+  }
+}
+
+/** pgvector literal format: "[0.1,0.2,...]". */
+function toVectorLiteral(vec: number[]): string {
+  return `[${vec.join(',')}]`;
+}
+
+/**
+ * Normalize caller userId for the layered read filter.
+ *
+ * The SQL filter is `(user_id IS NULL OR user_id = $2)`, so an empty
+ * string from the caller must not match rows whose user_id was set.
+ * We coerce empty/null/undefined to `null`, and pg treats `$2 = null`
+ * as `false` — which is exactly what we want for isolated callers:
+ * they see only agent-tier rows and nothing in the user tier.
+ */
+function normalizeCallerId(scope: MemoryScope): string | null {
+  const raw = scope.userId;
+  if (raw == null || raw === '') return null;
+  return String(raw);
+}
+
+export class PgvectorMemoryStore implements MemoryBackend {
+  readonly kind = 'vector' as const;
+  private pool: Pool;
+  private table: string;
+  private embedder: EmbeddingProvider;
+
+  constructor(opts: PgvectorStoreOptions) {
+    this.pool = opts.pool;
+    this.table = opts.table ?? DEFAULT_MEMORY_TABLE;
+    this.embedder = opts.embedder ?? getMemoryEmbedder();
+  }
+
+  async search(
+    scope: MemoryScope,
+    query: string,
+    opts: MemorySearchOptions = {}
+  ): Promise<MemoryEntry[]> {
+    assertScope(scope);
+    const trimmed = query.trim();
+    if (!trimmed) return [];
+
+    const maxResults = Math.max(
+      1,
+      opts.maxResults ?? DEFAULT_MAX_SEARCH_RESULTS
+    );
+    const minScore = opts.minScore ?? DEFAULT_MIN_SCORE;
+
+    const vector = await this.embedder.embed(trimmed);
+    const vectorLiteral = toVectorLiteral(vector);
+    const callerId = normalizeCallerId(scope);
+
+    // [memory-layered-search] debug: layered scope filter
+    //   agent-tier rows (user_id IS NULL) + this caller's user-tier rows.
+    //   Another user's rows are invisible at the SQL layer.
+    const sql = `
+      WITH scored AS (
+        SELECT
+          id,
+          path,
+          content,
+          created_at,
+          user_id,
+          (1 - (embedding <=> $1::vector)) AS vector_score,
+          ts_rank(tsv, plainto_tsquery('english', $2)) AS text_score
+        FROM ${this.table}
+        WHERE agent_id = $3
+          AND (user_id IS NULL OR user_id = $4)
+      )
+      SELECT
+        id,
+        path,
+        content,
+        created_at,
+        user_id,
+        (${HYBRID_VECTOR_WEIGHT} * vector_score + ${HYBRID_TEXT_WEIGHT} * text_score) AS score
+      FROM scored
+      WHERE (${HYBRID_VECTOR_WEIGHT} * vector_score + ${HYBRID_TEXT_WEIGHT} * text_score) >= $5
+      ORDER BY score DESC
+      LIMIT $6
+    `;
+
+    const { rows } = await this.pool.query(sql, [
+      vectorLiteral,
+      trimmed,
+      scope.agentId,
+      callerId,
+      minScore,
+      maxResults,
+    ]);
+
+    let hits: MemoryEntry[] = rows.map(
+      (row: {
+        id: string | number;
+        path: string;
+        content: string;
+        created_at: Date;
+        user_id: string | null;
+        score: string | number;
+      }): MemoryEntry => ({
+        id: String(row.id),
+        path: row.path,
+        content: row.content,
+        createdAt: new Date(row.created_at),
+        score: Number(row.score),
+        source: 'vector',
+        tier: getTierForPath(row.path),
+      })
+    );
+
+    // Phase 2: temporal decay (before MMR so diversity sees post-decay ranks)
+    if (opts.temporalDecay?.enabled) {
+      hits = applyTemporalDecayToHits(hits, opts.temporalDecay);
+      hits.sort((a, b) => b.score - a.score);
+    }
+
+    // Phase 2: MMR reranking
+    if (opts.mmr?.enabled) {
+      hits = applyMMRToMemoryHits(hits, opts.mmr);
+    }
+
+    // Phase 2: citations (decorate last — mutates content with Source: trailer)
+    const citationsMode = opts.citations ?? 'auto';
+    if (shouldIncludeCitations(citationsMode)) {
+      hits = decorateCitations(hits, true);
+    }
+
+    return hits;
+  }
+
+  async get(
+    scope: MemoryScope,
+    opts: MemoryGetOptions
+  ): Promise<MemoryReadResult | null> {
+    assertScope(scope);
+    if (!opts.path) return null;
+
+    const callerId = normalizeCallerId(scope);
+    const tier = getTierForPath(opts.path);
+
+    // Agent-tier rows always live under user_id=NULL. User-tier rows
+    // always carry the caller's id. Querying with a precise predicate
+    // is faster than leaving it open AND guarantees a user cannot
+    // read another user's row even if they know the path by heart.
+    const userClause = tier === 'agent' ? 'user_id IS NULL' : 'user_id = $3';
+
+    const params: unknown[] = [scope.agentId, opts.path];
+    if (tier === 'user') params.push(callerId);
+
+    const sql = `
+      SELECT content
+      FROM ${this.table}
+      WHERE agent_id = $1 AND path = $2 AND ${userClause}
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `;
+    const { rows } = await this.pool.query(sql, params);
+    if (rows.length === 0) return null;
+
+    const text = String(rows[0].content ?? '');
+    if (opts.from == null && opts.lines == null) {
+      return { path: opts.path, text };
+    }
+
+    const allLines = text.split('\n');
+    const fromIdx = Math.max(0, (opts.from ?? 1) - 1);
+    const count = Math.max(0, opts.lines ?? allLines.length - fromIdx);
+    const slice = allLines.slice(fromIdx, fromIdx + count).join('\n');
+    return { path: opts.path, text: slice };
+  }
+
+  async append(scope: MemoryScope, input: MemoryAppendInput): Promise<void> {
+    assertScope(scope);
+    // Whitelist + tier + scope-compatibility check in one call. Throws
+    // with an actionable message for each failure mode.
+    const descriptor = assertWritablePath(input.path, scope);
+    const content = input.content.trim();
+    if (!content) {
+      throw new Error('memory_append content must be non-empty');
+    }
+
+    // Tier determines the row's user_id:
+    //   agent tier → NULL (shared across all users)
+    //   user tier  → the caller's id (assertWritablePath guarantees non-empty)
+    const rowUserId = descriptor.tier === 'agent' ? null : String(scope.userId);
+    const provenance = scope.userId != null ? String(scope.userId) : null;
+
+    // Read the existing row (if any) for THIS tier so we can embed the
+    // merged content. Agent-tier merges regardless of caller; user-tier
+    // merges only within the caller's own row.
+    const lookupSql = `
+      SELECT content FROM ${this.table}
+      WHERE agent_id = $1 AND path = $2 AND ${rowUserId === null ? 'user_id IS NULL' : 'user_id = $3'}
+      LIMIT 1
+    `;
+    const lookupParams: unknown[] =
+      rowUserId === null
+        ? [scope.agentId, input.path]
+        : [scope.agentId, input.path, rowUserId];
+    const existing = await this.pool.query(lookupSql, lookupParams);
+    const priorContent: string =
+      existing.rows.length > 0 ? String(existing.rows[0].content ?? '') : '';
+    const mergedContent = priorContent
+      ? `${priorContent.replace(/\s+$/, '')}\n\n${content}`
+      : content;
+
+    const vector = await this.embedder.embed(mergedContent);
+    const vectorLiteral = toVectorLiteral(vector);
+
+    // UPSERT on (agent_id, user_id, path) with NULLS NOT DISTINCT so
+    // two NULL user_ids collide on the same agent+path (exactly one
+    // agent-tier row) while per-user rows on the same path coexist.
+    //
+    // Provenance note: `last_user_id` always records WHO wrote the
+    // latest append, even for agent-tier rows where the row's own
+    // `user_id` stays NULL. That gives the admin UI an audit trail
+    // ("agent-tier row last updated by Alice") without changing the
+    // scoping semantics.
+    const upsertSql = `
+      INSERT INTO ${this.table} (agent_id, user_id, path, content, embedding, last_user_id, updated_at)
+      VALUES ($1, $2, $3, $4, $5::vector, $6, NOW())
+      ON CONFLICT (agent_id, user_id, path) DO UPDATE
+      SET content      = EXCLUDED.content,
+          embedding    = EXCLUDED.embedding,
+          last_user_id = EXCLUDED.last_user_id,
+          updated_at   = NOW()
+    `;
+    await this.pool.query(upsertSql, [
+      scope.agentId,
+      rowUserId,
+      input.path,
+      mergedContent,
+      vectorLiteral,
+      provenance,
+    ]);
+  }
+
+  async health(): Promise<MemoryHealth> {
+    try {
+      await this.pool.query('SELECT 1');
+      return { ok: true, backend: 'vector' };
+    } catch (err) {
+      return {
+        ok: false,
+        backend: 'vector',
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+}

package/src/memory/recallTracking.ts

@@ -0,0 +1,127 @@
+/**
+ * Recall tracking — Phase 2.
+ *
+ * Lightweight adaptation of upstream
+ * `extensions/memory-core/src/short-term-promotion.ts::recordShortTermRecalls`.
+ * Upstream stores recalls in a JSON file under `memory/.dreams/`; we store
+ * them in a Postgres table `agent_memory_recalls`. Schema captures what the
+ * future Phase 3 dreaming/promotion algorithm will need:
+ *   - which memory row was surfaced (`memory_id`)
+ *   - the query that surfaced it (raw + SHA-256 hash for dedupe)
+ *   - hybrid score at the time of recall
+ *   - the day bucket (for per-day dedupe / frequency counting)
+ *   - the recorded timestamp
+ *
+ * Best-effort: failures never block memory_search. The caller fires
+ * {@link RecallTracker.record} without awaiting the result and ignores errors.
+ */
+import { createHash } from 'crypto';
+import type { Pool } from 'pg';
+
+export interface RecallTracker {
+  /** Record that the given memory ids were surfaced to the model for a query. */
+  record(params: RecallRecordParams): Promise<void>;
+  /** Backend-specific schema migration. Idempotent. */
+  migrate(): Promise<void>;
+}
+
+export interface RecallRecordParams {
+  agentId: string;
+  query: string;
+  hits: Array<{ id: string; path: string; score: number }>;
+  nowMs?: number;
+}
+
+export const RECALL_TABLE = 'agent_memory_recalls';
+
+function hashQuery(query: string): string {
+  return createHash('sha256')
+    .update(query.trim().toLowerCase())
+    .digest('hex')
+    .slice(0, 32);
+}
+
+function dayBucket(nowMs: number): string {
+  const d = new Date(nowMs);
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(d.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+export class PgvectorRecallTracker implements RecallTracker {
+  constructor(
+    private readonly pool: Pool,
+    private readonly table: string = RECALL_TABLE
+  ) {}
+
+  async migrate(): Promise<void> {
+    // [recall-tracking] debug: create table + indexes if missing
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        id           BIGSERIAL   PRIMARY KEY,
+        agent_id     TEXT        NOT NULL,
+        memory_id    TEXT        NOT NULL,
+        memory_path  TEXT        NOT NULL,
+        query        TEXT        NOT NULL,
+        query_hash   TEXT        NOT NULL,
+        score        DOUBLE PRECISION NOT NULL,
+        day_bucket   TEXT        NOT NULL,
+        recorded_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await this.pool.query(
+      `CREATE INDEX IF NOT EXISTS ${this.table}_agent_day_idx ON ${this.table} (agent_id, day_bucket)`
+    );
+    await this.pool.query(
+      `CREATE INDEX IF NOT EXISTS ${this.table}_memory_idx ON ${this.table} (agent_id, memory_id)`
+    );
+    await this.pool.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS ${this.table}_dedupe_idx
+       ON ${this.table} (agent_id, memory_id, query_hash, day_bucket)`
+    );
+  }
+
+  async record(params: RecallRecordParams): Promise<void> {
+    if (!params.agentId || !params.query.trim() || params.hits.length === 0)
+      return;
+    const nowMs = params.nowMs ?? Date.now();
+    const qhash = hashQuery(params.query);
+    const bucket = dayBucket(nowMs);
+
+    // [recall-tracking] debug: upsert one row per (agent, memory, query, day)
+    // Upstream dedupes per-day per-query so repeated searches don't inflate counts.
+    const values: string[] = [];
+    const args: unknown[] = [];
+    let i = 1;
+    for (const hit of params.hits) {
+      values.push(
+        `($${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, $${i++}, NOW())`
+      );
+      args.push(
+        params.agentId,
+        hit.id,
+        hit.path,
+        params.query,
+        qhash,
+        hit.score,
+        bucket
+      );
+    }
+    const sql = `
+      INSERT INTO ${this.table}
+        (agent_id, memory_id, memory_path, query, query_hash, score, day_bucket, recorded_at)
+      VALUES ${values.join(', ')}
+      ON CONFLICT (agent_id, memory_id, query_hash, day_bucket) DO UPDATE
+      SET score       = GREATEST(${this.table}.score, EXCLUDED.score),
+          recorded_at = NOW()
+    `;
+    await this.pool.query(sql, args);
+  }
+}
+
+/** No-op tracker — used when recall tracking is disabled or the backend isn't pgvector. */
+export class NullRecallTracker implements RecallTracker {
+  async record(): Promise<void> {}
+  async migrate(): Promise<void> {}
+}

package/src/memory/schema.sql

@@ -0,0 +1,51 @@
+-- Autonomous memory — Postgres schema (v2: layered tier scoping).
+--
+-- Two-tier canonical-document model:
+--
+--   memory/agent/*   → shared across every user of the agent (user_id = NULL)
+--   memory/user/*    → private to a specific caller (user_id = <callerId>)
+--
+-- Uniqueness key is `(agent_id, user_id, path)` with NULLS NOT DISTINCT
+-- so two NULL user_id rows on the same path collide (exactly-one
+-- agent-tier row per path) while per-user rows on the same path coexist
+-- (one row per user for user-tier paths).
+--
+-- The read path filters with `(user_id IS NULL OR user_id = $caller)`,
+-- so callers see agent-tier rows + only their own user-tier rows —
+-- never another user's private memory. Enforcement is in SQL, not just
+-- the UI.
+--
+-- NULLS NOT DISTINCT requires PostgreSQL 15+. Host's production
+-- pgvector image is PG16, so this is safe. The migration in
+-- `migrate.ts` will drop the legacy `(agent_id, path)` constraint
+-- before creating the new one if it exists on an older database.
+
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE IF NOT EXISTS agent_memories (
+  id           BIGSERIAL   PRIMARY KEY,
+  agent_id     TEXT        NOT NULL,
+  user_id      TEXT,                                -- NULL = agent-tier, shared
+  path         TEXT        NOT NULL,
+  content      TEXT        NOT NULL,
+  embedding    VECTOR(1024),
+  tsv          TSVECTOR    GENERATED ALWAYS AS (to_tsvector('english', content)) STORED,
+  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  last_user_id TEXT,                                -- latest session to append
+  CONSTRAINT agent_memories_agent_user_path_uq
+    UNIQUE NULLS NOT DISTINCT (agent_id, user_id, path)
+);
+
+-- Primary lookup index for list/search/generate-prompt — matches the
+-- exact filter shape of every read query.
+CREATE INDEX IF NOT EXISTS agent_memories_scope_idx
+  ON agent_memories (agent_id, user_id, path);
+
+-- Vector ANN index — untouched by the scoping change.
+CREATE INDEX IF NOT EXISTS agent_memories_vector_idx
+  ON agent_memories USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+
+-- Full-text GIN index — untouched.
+CREATE INDEX IF NOT EXISTS agent_memories_tsv_idx
+  ON agent_memories USING GIN (tsv);

package/src/memory/temporalDecay.ts

@@ -0,0 +1,134 @@
+/**
+ * Temporal decay — Phase 2.
+ *
+ * Ported from upstream `extensions/memory-core/src/memory/temporal-decay.ts`.
+ * Ages dated memory files (`memory/YYYY-MM-DD.md`) using exponential decay
+ * `multiplier = exp(-ln(2) / halfLifeDays * ageInDays)`. At half-life, the
+ * score is exactly halved.
+ *
+ * Evergreen files (MEMORY.md, memory/topics.md, any non-dated file inside
+ * memory/) do NOT decay — they represent durable knowledge and should stay
+ * hot regardless of age. This mirrors upstream's `isEvergreenMemoryPath`.
+ *
+ * Since our pgvector rows carry `createdAt`, we don't need filesystem stat
+ * fallback — the row timestamp is authoritative for any file without a
+ * date in the path.
+ */
+
+export interface TemporalDecayConfig {
+  enabled: boolean;
+  halfLifeDays: number;
+}
+
+export const DEFAULT_TEMPORAL_DECAY_CONFIG: TemporalDecayConfig = {
+  enabled: false,
+  halfLifeDays: 30,
+};
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DATED_MEMORY_PATH_RE = /(?:^|\/)memory\/(\d{4})-(\d{2})-(\d{2})\.md$/;
+
+export function toDecayLambda(halfLifeDays: number): number {
+  if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) return 0;
+  return Math.LN2 / halfLifeDays;
+}
+
+export function calculateTemporalDecayMultiplier(params: {
+  ageInDays: number;
+  halfLifeDays: number;
+}): number {
+  const lambda = toDecayLambda(params.halfLifeDays);
+  const age = Math.max(0, params.ageInDays);
+  if (lambda <= 0 || !Number.isFinite(age)) return 1;
+  return Math.exp(-lambda * age);
+}
+
+export function applyTemporalDecayToScore(params: {
+  score: number;
+  ageInDays: number;
+  halfLifeDays: number;
+}): number {
+  return params.score * calculateTemporalDecayMultiplier(params);
+}
+
+function normalizePath(p: string): string {
+  return (p ?? '').replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+/** Parse a date out of `memory/YYYY-MM-DD.md` — returns null on non-match or invalid date. */
+export function parseMemoryDateFromPath(filePath: string): Date | null {
+  const m = DATED_MEMORY_PATH_RE.exec(normalizePath(filePath));
+  if (!m) return null;
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  if (!Number.isInteger(y) || !Number.isInteger(mo) || !Number.isInteger(d))
+    return null;
+  const ts = Date.UTC(y, mo - 1, d);
+  const parsed = new Date(ts);
+  if (
+    parsed.getUTCFullYear() !== y ||
+    parsed.getUTCMonth() !== mo - 1 ||
+    parsed.getUTCDate() !== d
+  ) {
+    return null;
+  }
+  return parsed;
+}
+
+/**
+ * Evergreen = durable knowledge file that should not decay.
+ * - `MEMORY.md` / `memory.md` at root
+ * - anything inside `memory/` that is NOT a dated `YYYY-MM-DD.md` file
+ */
+export function isEvergreenMemoryPath(filePath: string): boolean {
+  const n = normalizePath(filePath);
+  if (n === 'MEMORY.md' || n === 'memory.md') return true;
+  if (!n.startsWith('memory/')) return false;
+  return !DATED_MEMORY_PATH_RE.test(n);
+}
+
+function ageInDays(timestamp: Date, nowMs: number): number {
+  return Math.max(0, nowMs - timestamp.getTime()) / DAY_MS;
+}
+
+export interface DecayCandidate {
+  path: string;
+  score: number;
+  createdAt?: Date;
+}
+
+/**
+ * Apply temporal decay to a list of memory hits.
+ *
+ * Priority for the effective timestamp:
+ *   1. Dated path (`memory/YYYY-MM-DD.md`) — use the date in the path
+ *   2. Otherwise, if the path is evergreen — NO decay
+ *   3. Otherwise, use the row's `createdAt`
+ */
+export function applyTemporalDecayToHits<T extends DecayCandidate>(
+  hits: T[],
+  config: Partial<TemporalDecayConfig> = {},
+  nowMs: number = Date.now()
+): T[] {
+  const merged = { ...DEFAULT_TEMPORAL_DECAY_CONFIG, ...config };
+  if (!merged.enabled) return [...hits];
+
+  return hits.map((h) => {
+    const datedTs = parseMemoryDateFromPath(h.path);
+    let ts: Date | null = datedTs;
+    if (!ts) {
+      if (isEvergreenMemoryPath(h.path)) return h;
+      ts = h.createdAt ?? null;
+    }
+    if (!ts) return h;
+    return {
+      ...h,
+      score: applyTemporalDecayToScore({
+        score: h.score,
+        ageInDays: ageInDays(ts, nowMs),
+        halfLifeDays: merged.halfLifeDays,
+      }),
+    };
+  });
+}