@sentry/junior-memory 0.198.0 → 0.199.0

package/src/events.ts

@@ -1,107 +0,0 @@
-import { defineConversationEvent } from "@sentry/junior-plugin-api";
-import { z } from "zod";
-import { MEMORY_KINDS, MEMORY_SCOPES } from "./types";
-import type { MemoryRecord } from "./store";
-
-const capturedMemoryFields = {
-  content: z.string().min(1),
-  id: z.string().min(1),
-  kind: z.enum(MEMORY_KINDS),
-  observedAtMs: z.number().finite(),
-};
-
-const legacyCapturedMemorySchema = z
-  .object({
-    ...capturedMemoryFields,
-    scope: z.enum(["personal", "conversation"]),
-  })
-  .strict();
-
-const capturedMemorySchema = z
-  .object({
-    ...capturedMemoryFields,
-    scope: z.enum(MEMORY_SCOPES),
-  })
-  .strict();
-
-const capturedMemoriesSchema = z
-  .object({
-    memories: z.array(capturedMemorySchema).max(100),
-    costUsd: z.number().finite().nonnegative().optional(),
-  })
-  .strict();
-
-const recalledMemoriesSchema = z
-  .object({
-    // Matches the automatic-recall candidate window; admission packs by char budget.
-    memories: z.array(z.string().min(1)).max(20),
-    costUsd: z.number().finite().nonnegative().optional(),
-  })
-  .strict();
-
-function currentScope(
-  scope: "personal" | "conversation" | "private" | "public",
-) {
-  if (scope === "personal") return "private";
-  if (scope === "conversation") return "public";
-  return scope;
-}
-
-function renderCapturedMemories(event: {
-  memories: Array<
-    | z.output<typeof legacyCapturedMemorySchema>
-    | z.output<typeof capturedMemorySchema>
-  >;
-}) {
-  const count = event.memories.length;
-  if (count === 0) return undefined;
-  return {
-    icon: "brain" as const,
-    title: `${count} ${count === 1 ? "memory" : "memories"} captured`,
-    details: event.memories.map((memory) => ({
-      title: memory.content,
-      metadata: [memory.kind, currentScope(memory.scope)],
-    })),
-  };
-}
-
-/** Previous stored memory-capture event shape retained for transcript rendering. */
-export const memoriesCapturedEventV1 = defineConversationEvent({
-  name: "memories_captured",
-  version: 1,
-  schema: z
-    .object({
-      memories: z.array(legacyCapturedMemorySchema).min(1).max(100),
-    })
-    .strict(),
-  renderEvent: renderCapturedMemories,
-});
-
-/** Durable outcome emitted after every completed passive memory extraction. */
-export const memoriesCapturedEvent = defineConversationEvent({
-  name: "memories_captured",
-  version: 2,
-  schema: capturedMemoriesSchema,
-  renderEvent: renderCapturedMemories,
-});
-
-/** Durable outcome emitted after one completed automatic recall attempt. */
-export const memoriesRecalledEvent = defineConversationEvent({
-  name: "memories_recalled",
-  version: 1,
-  schema: recalledMemoriesSchema,
-  renderEvent() {
-    return undefined;
-  },
-});
-
-/** Select the stable, safe memory fields retained in conversation history. */
-export function capturedMemory(memory: MemoryRecord) {
-  return {
-    content: memory.content,
-    id: memory.id,
-    kind: memory.kind,
-    observedAtMs: memory.observedAtMs,
-    scope: memory.scope,
-  };
-}

package/src/index.ts

@@ -1,25 +0,0 @@
-export { memoryPlugin } from "./plugin";
-export {
-  memoryApiSchema,
-  memoryDashboardResponseSchema,
-  memoryListResponseSchema,
-  type MemoryApi,
-  type MemoryDashboardResponse,
-  type MemoryListResponse,
-} from "./api";
-export type { MemoryPluginOptions } from "./plugin";
-export { createMemoryStore } from "./store";
-export type {
-  ArchiveMemoryInput,
-  CreateMemoryInput,
-  CreateMemoryResult,
-  ListMemoriesInput,
-  MemoryDb,
-  MemoryEmbeddingProvider,
-  MemoryRecord,
-  MemoryStore,
-  MemoryStoreOptions,
-  SearchMemoriesInput,
-} from "./store";
-export { MEMORY_KINDS } from "./types";
-export type { MemoryKind, MemoryRuntimeContext } from "./types";

package/src/operational-report.ts

@@ -1,228 +0,0 @@
-import type {
-  PluginConversationEventCostDay,
-  PluginOperationalReportContent,
-} from "@sentry/junior-plugin-api";
-import { and, eq, gt, isNull, or, sql } from "drizzle-orm";
-import { z } from "zod";
-import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
-import type { MemoryDb } from "./store";
-
-const DAY_MS = 24 * 60 * 60 * 1_000;
-// TODO: add hour categories + `1` when these system widgets can plot 24h hourly.
-const WINDOWS = [7, 30, 90] as const;
-
-const memoryDaySchema = z
-  .object({
-    date: z.string().date(),
-    private: z.number().int().nonnegative(),
-    public: z.number().int().nonnegative(),
-  })
-  .strict();
-
-function queryRows(result: unknown): unknown[] {
-  if (
-    typeof result !== "object" ||
-    result === null ||
-    !("rows" in result) ||
-    !Array.isArray(result.rows)
-  ) {
-    throw new TypeError("Memory activity query did not return rows");
-  }
-  return result.rows;
-}
-
-function startOfUtcDay(value: number): Date {
-  const date = new Date(value);
-  date.setUTCHours(0, 0, 0, 0);
-  return date;
-}
-
-async function aggregateMemoryDays(args: { db: MemoryDb; nowMs: number }) {
-  const end = startOfUtcDay(args.nowMs);
-  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1)! - 1) * DAY_MS);
-  const endExclusiveMs = end.getTime() + DAY_MS;
-  const table = juniorMemoryMemories;
-  const result = await args.db.execute(sql`
-    WITH days AS (
-      SELECT generate_series(
-        date_trunc('day', ${start}::timestamptz AT TIME ZONE 'UTC'),
-        date_trunc('day', ${end}::timestamptz AT TIME ZONE 'UTC'),
-        interval '1 day'
-      ) AS day
-    ), daily AS (
-      SELECT
-        date_trunc(
-          'day',
-          to_timestamp(${table.createdAtMs} / 1000.0) AT TIME ZONE 'UTC'
-        ) AS day,
-        count(*) FILTER (
-          WHERE ${table.scope} = 'private'
-        )::integer AS private,
-        count(*) FILTER (
-          WHERE ${table.scope} = 'public'
-        )::integer AS public
-      FROM ${table}
-      WHERE ${table.createdAtMs} >= ${start.getTime()}
-        AND ${table.createdAtMs} < ${endExclusiveMs}
-      GROUP BY date_trunc(
-        'day',
-        to_timestamp(${table.createdAtMs} / 1000.0) AT TIME ZONE 'UTC'
-      )
-    )
-    SELECT
-      to_char(days.day, 'YYYY-MM-DD') AS date,
-      coalesce(daily.private, 0)::integer AS private,
-      coalesce(daily.public, 0)::integer AS public
-    FROM days
-    LEFT JOIN daily ON daily.day = days.day
-    ORDER BY days.day
-  `);
-  return z.array(memoryDaySchema).parse(queryRows(result));
-}
-
-function formatCount(value: number): string {
-  return new Intl.NumberFormat("en-US").format(value);
-}
-
-function formatPercent(value: number): string {
-  return new Intl.NumberFormat("en-US", {
-    maximumFractionDigits: 0,
-    style: "percent",
-  }).format(value);
-}
-
-function formatUsd(value: number): string {
-  const maximumFractionDigits = value > 0 && value < 0.01 ? 4 : 2;
-  return new Intl.NumberFormat("en-US", {
-    currency: "USD",
-    maximumFractionDigits,
-    minimumFractionDigits: 2,
-    style: "currency",
-  }).format(value);
-}
-
-/** Build aggregate memory storage and indexing diagnostics for the System page. */
-export async function buildMemoryOperationalReport(args: {
-  db: MemoryDb;
-  extractionDays: PluginConversationEventCostDay[];
-  nowMs: number;
-}): Promise<PluginOperationalReportContent> {
-  const active = and(
-    isNull(juniorMemoryMemories.archivedAtMs),
-    isNull(juniorMemoryMemories.supersededAtMs),
-    isNull(juniorMemoryMemories.supersededById),
-    or(
-      isNull(juniorMemoryMemories.expiresAtMs),
-      gt(juniorMemoryMemories.expiresAtMs, args.nowMs),
-    ),
-  );
-  const [[counts], memoryDays] = await Promise.all([
-    args.db
-      .select({
-        active: sql<number>`count(*) filter (where ${active})`.mapWith(Number),
-        public:
-          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'public')`.mapWith(
-            Number,
-          ),
-        createdThirtyDays:
-          sql<number>`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS})`.mapWith(
-            Number,
-          ),
-        embedded:
-          sql<number>`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
-            Number,
-          ),
-        private:
-          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'private')`.mapWith(
-            Number,
-          ),
-      })
-      .from(juniorMemoryMemories)
-      .leftJoin(
-        juniorMemoryEmbeddings,
-        eq(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id),
-      ),
-    aggregateMemoryDays(args),
-  ]);
-
-  const activeCount = counts?.active ?? 0;
-  const embeddedCount = counts?.embedded ?? 0;
-  const embeddingCoverage = activeCount === 0 ? 0 : embeddedCount / activeCount;
-  const extractionThirtyDays = args.extractionDays.slice(-30);
-  const extractionCostThirtyDays = extractionThirtyDays.reduce(
-    (total, day) => total + day.costUsd,
-    0,
-  );
-
-  return {
-    generatedAt: new Date(args.nowMs).toISOString(),
-    title: "Memory",
-    metrics: [
-      {
-        label: "active memories",
-        tone: activeCount > 0 ? "good" : "neutral",
-        value: formatCount(activeCount),
-      },
-      {
-        label: "extraction cost · 30d",
-        value: formatUsd(extractionCostThirtyDays),
-      },
-      {
-        label: "created · 30d",
-        value: formatCount(counts?.createdThirtyDays ?? 0),
-      },
-      {
-        label: "private",
-        value: formatCount(counts?.private ?? 0),
-      },
-      {
-        label: "public",
-        value: formatCount(counts?.public ?? 0),
-      },
-      {
-        label: "embedding coverage",
-        tone:
-          activeCount === 0
-            ? "neutral"
-            : embeddedCount === activeCount
-              ? "good"
-              : "warning",
-        value: formatPercent(embeddingCoverage),
-      },
-    ],
-    widgets: [
-      {
-        categories: args.extractionDays.map((day) => ({
-          id: day.date,
-          label: day.date,
-          values: { costUsd: day.costUsd },
-        })),
-        description: "Estimated model cost of passive memory extraction",
-        id: "extraction-cost",
-        series: [{ format: "usd", key: "costUsd", label: "Cost" }],
-        timeRangeDays: [...WINDOWS],
-        title: "Extraction cost",
-        type: "bar_chart",
-      },
-      {
-        categories: memoryDays.map((day) => ({
-          id: day.date,
-          label: day.date,
-          values: {
-            private: day.private,
-            public: day.public,
-          },
-        })),
-        description: "Memories stored by scope",
-        id: "memories-created",
-        series: [
-          { key: "private", label: "Private" },
-          { key: "public", label: "Public" },
-        ],
-        timeRangeDays: [...WINDOWS],
-        title: "Memories created",
-        type: "bar_chart",
-      },
-    ],
-  };
-}

package/src/plugin.ts

@@ -1,186 +0,0 @@
-import { defineJuniorPlugin } from "@sentry/junior-plugin-api";
-import { createMemoryAgent } from "./agent";
-import { createMemoryApi } from "./api";
-import { createMemoryCliCommand } from "./cli";
-import {
-  createMemoryCreateTool,
-  createMemoryListTool,
-  createMemoryRemoveTool,
-  createMemorySearchTool,
-  type MemoryCreateToolContext,
-  type MemoryReviewer,
-  type MemoryToolContext,
-} from "./tools";
-import { processMemorySession } from "./process-session";
-import { createMemoryPromptContributions } from "./recall";
-import { buildMemoryOperationalReport } from "./operational-report";
-import {
-  memoriesCapturedEvent,
-  memoriesCapturedEventV1,
-  memoriesRecalledEvent,
-} from "./events";
-import type { MemoryDb } from "./store";
-import { createMemoryUserPage } from "./user-pages";
-
-const MEMORY_MODEL_ENV = "AI_MEMORY_MODEL";
-
-export interface MemoryPluginOptions {
-  /** Disable automatic prompt recall while keeping explicit memory tools available. */
-  disableRecall?: boolean;
-  /** Disable passive memory extraction from completed sessions. */
-  disableExtraction?: boolean;
-  modelId?: string;
-}
-
-function memoryModelId(options: MemoryPluginOptions): string | undefined {
-  const explicitModelId = options.modelId?.trim();
-  if (explicitModelId) {
-    return explicitModelId;
-  }
-  const envModelId = process.env[MEMORY_MODEL_ENV]?.trim();
-  return envModelId || undefined;
-}
-
-function memoryToolContext(ctx: {
-  agent: MemoryReviewer;
-  conversationId?: string;
-  db: MemoryToolContext["db"];
-  embedder?: MemoryToolContext["embedder"];
-  locationId?: string;
-  actor?: MemoryToolContext["actor"];
-  source: MemoryToolContext["source"];
-  users: MemoryToolContext["users"];
-  userText?: string;
-}): MemoryToolContext {
-  return {
-    agent: ctx.agent,
-    ...(ctx.conversationId
-      ? { conversationId: ctx.conversationId }
-      : undefined),
-    ...(ctx.actor ? { actor: ctx.actor } : undefined),
-    db: ctx.db,
-    ...(ctx.embedder ? { embedder: ctx.embedder } : undefined),
-    ...(ctx.locationId ? { locationId: ctx.locationId } : undefined),
-    source: ctx.source,
-    users: ctx.users,
-    ...(ctx.userText ? { userText: ctx.userText } : undefined),
-  };
-}
-
-function memoryCreateToolContext(ctx: {
-  agent: MemoryReviewer;
-  conversationId?: string;
-  db: MemoryCreateToolContext["db"];
-  embedder?: MemoryCreateToolContext["embedder"];
-  locationId?: string;
-  actor?: MemoryCreateToolContext["actor"];
-  source: MemoryCreateToolContext["source"];
-  supersessionDecider: MemoryCreateToolContext["supersessionDecider"];
-  users: MemoryCreateToolContext["users"];
-  userText?: string;
-}): MemoryCreateToolContext {
-  return {
-    ...memoryToolContext(ctx),
-    supersessionDecider: ctx.supersessionDecider,
-  };
-}
-
-/** Register Junior's long-term memory plugin. */
-export function memoryPlugin(options: MemoryPluginOptions = {}) {
-  const modelId = memoryModelId(options);
-  return defineJuniorPlugin({
-    manifest: {
-      name: "memory",
-      displayName: "Memory",
-      description: "Long-term Junior memory storage and recall",
-    },
-    model: modelId
-      ? { structuredModelId: modelId }
-      : { structuredModel: "default" },
-    packageName: "@sentry/junior-memory",
-    conversationEvents: [
-      memoriesCapturedEventV1,
-      memoriesCapturedEvent,
-      memoriesRecalledEvent,
-    ],
-    cli: {
-      commands: [createMemoryCliCommand()],
-    },
-    tasks: options.disableExtraction
-      ? {}
-      : {
-          processSession: {
-            async run(ctx) {
-              await processMemorySession(ctx);
-            },
-          },
-        },
-    userPages: [createMemoryUserPage()],
-    hooks: {
-      async operationalReport(ctx) {
-        const extractionDays = await ctx.eventStats.costsByDay({
-          days: 90,
-          eventName: "memories_captured",
-        });
-        return await buildMemoryOperationalReport({
-          db: ctx.db as MemoryDb,
-          extractionDays,
-          nowMs: ctx.nowMs,
-        });
-      },
-      apiRoutes(ctx) {
-        return createMemoryApi({
-          db: ctx.db as MemoryDb,
-          eventStats: ctx.eventStats,
-          users: ctx.users,
-        });
-      },
-      tools(ctx) {
-        const agent = createMemoryAgent(ctx.model);
-        const context = memoryToolContext({
-          ...ctx,
-          agent,
-          db: ctx.db as MemoryDb,
-          embedder: ctx.embedder,
-        });
-        return {
-          createMemory: createMemoryCreateTool(
-            memoryCreateToolContext({
-              ...ctx,
-              agent,
-              db: ctx.db as MemoryDb,
-              embedder: ctx.embedder,
-              supersessionDecider: agent,
-            }),
-          ),
-          removeMemory: createMemoryRemoveTool(context),
-          listMemories: createMemoryListTool(context),
-          searchMemories: createMemorySearchTool(context),
-        };
-      },
-      ...(!options.disableRecall
-        ? {
-            async userPrompt(ctx) {
-              return await createMemoryPromptContributions({
-                agent: createMemoryAgent(ctx.model),
-                ...(ctx.conversationId
-                  ? { conversationId: ctx.conversationId }
-                  : undefined),
-                ...(ctx.actor ? { actor: ctx.actor } : undefined),
-                db: ctx.db as MemoryDb,
-                embedder: ctx.embedder,
-                events: ctx.events,
-                ...(ctx.locationId
-                  ? { locationId: ctx.locationId }
-                  : undefined),
-                log: ctx.log,
-                source: ctx.source,
-                text: ctx.text,
-                users: ctx.users,
-              });
-            },
-          }
-        : undefined),
-    },
-  });
-}