@sentry/junior-memory 0.124.2 → 0.126.0

package/dist/operational-report.d.ts

@@ -1,7 +1,8 @@
-import type { PluginOperationalReportContent } from "@sentry/junior-plugin-api";
+import type { PluginConversationEventCostDay, PluginOperationalReportContent } from "@sentry/junior-plugin-api";
 import type { MemoryDb } from "./store";
 /** Build aggregate memory storage and indexing diagnostics for the System page. */
 export declare function buildMemoryOperationalReport(args: {
     db: MemoryDb;
+    extractionDays: PluginConversationEventCostDay[];
     nowMs: number;
 }): Promise<PluginOperationalReportContent>;

package/dist/recall.d.ts

@@ -1,4 +1,4 @@
-import { type UserPromptContribution, type Actor, type PluginLogger, type Source } from "@sentry/junior-plugin-api";
+import { type UserPromptContribution, type Actor, type PluginConversationEvents, type PluginLogger, type Source } from "@sentry/junior-plugin-api";
 import { z } from "zod";
 import type { MemoryAgent } from "./agent";
 import { type MemoryDb, type MemoryEmbeddingProvider } from "./store";
@@ -7,6 +7,7 @@ export interface MemoryRecallContext {
     conversationId?: string;
     db: MemoryDb;
     embedder?: MemoryEmbeddingProvider;
+    events?: PluginConversationEvents;
     log: PluginLogger;
     /** Maximum cosine distance for vector recall. Passed through to the memory store. */
     maxVectorDistance?: number;

package/dist/store.d.ts

@@ -79,9 +79,9 @@ export declare const memorySupersessionInputSchema: z.ZodObject<{
             platform: z.ZodLiteral<"slack">;
             teamId: z.ZodString;
             channelId: z.ZodString;
-            type: z.ZodEnum<{
-                pub: "pub";
-                priv: "priv";
+            visibility: z.ZodEnum<{
+                public: "public";
+                private: "private";
             }>;
             messageTs: z.ZodOptional<z.ZodString>;
             threadTs: z.ZodOptional<z.ZodString>;
@@ -97,7 +97,7 @@ export declare const memorySupersessionInputSchema: z.ZodObject<{
         }, z.core.$strict>>;
         source: z.ZodObject<{
             platform: z.ZodLiteral<"local">;
-            type: z.ZodLiteral<"priv">;
+            visibility: z.ZodLiteral<"private">;
             conversationId: z.ZodString;
         }, z.core.$strict>;
     }, z.core.$strict>]>;
@@ -141,6 +141,7 @@ export interface MemoryEmbeddingProvider {
     embedTexts(input: {
         texts: string[];
     }): Promise<{
+        costUsd?: number;
         dimensions: number;
         model: string;
         provider: string;

package/dist/types.d.ts

@@ -25,9 +25,9 @@ export declare const slackMemoryRuntimeContextSchema: z.ZodObject<{
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        type: z.ZodEnum<{
-            pub: "pub";
-            priv: "priv";
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
         }>;
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
@@ -45,7 +45,7 @@ export declare const localMemoryRuntimeContextSchema: z.ZodObject<{
     }, z.core.$strict>>;
     source: z.ZodObject<{
         platform: z.ZodLiteral<"local">;
-        type: z.ZodLiteral<"priv">;
+        visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -64,9 +64,9 @@ export declare const memoryRuntimeContextSchema: z.ZodUnion<readonly [z.ZodObjec
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
-        type: z.ZodEnum<{
-            pub: "pub";
-            priv: "priv";
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
         }>;
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
@@ -82,7 +82,7 @@ export declare const memoryRuntimeContextSchema: z.ZodUnion<readonly [z.ZodObjec
     }, z.core.$strict>>;
     source: z.ZodObject<{
         platform: z.ZodLiteral<"local">;
-        type: z.ZodLiteral<"priv">;
+        visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.124.2",
+  "version": "0.126.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.124.2"
+    "@sentry/junior-plugin-api": "0.126.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/agent.ts

@@ -199,18 +199,30 @@ export type ExtractSessionRequest = z.output<
 >;
 export type ExtractedMemory = z.output<typeof extractedMemoryResultSchema>;
 
+/** Memories proposed by passive extraction and the model cost of that pass. */
+export type MemoryExtractionResult = {
+  costUsd?: number;
+  memories: ExtractedMemory[];
+};
+
+/** Memories admitted by automatic recall and the model cost of that decision. */
+export type MemoryRecallResult = {
+  costUsd?: number;
+  relevantIds: string[];
+};
+
 export interface MemoryAgent {
   /** Select candidate memories that directly help with the current request. */
   selectRelevantMemories(
     request: MemoryRecallInput,
-  ): Promise<string[]> | string[];
+  ): Promise<MemoryRecallResult> | MemoryRecallResult;
   /** Classify a new preference against related active preferences. */
   adjudicateSupersession(
     request: MemorySupersessionInput,
   ): Promise<MemorySupersessionDecision> | MemorySupersessionDecision;
   extractSessionMemories(
     request: ExtractSessionRequest,
-  ): Promise<ExtractedMemory[]> | ExtractedMemory[];
+  ): Promise<MemoryExtractionResult> | MemoryExtractionResult;
   reviewCreateRequest(
     request: CreateMemoryRequest,
   ): Promise<MemoryReview> | MemoryReview;
@@ -540,9 +552,12 @@ export function createMemoryAgent(model: PluginModel): MemoryAgent {
       });
       const decision = memoryRecallDecisionSchema.parse(result.object);
       const candidateIds = new Set(request.candidates.map(({ id }) => id));
-      return [...new Set(decision.relevantIds)].filter((id) =>
-        candidateIds.has(id),
-      );
+      return {
+        relevantIds: [...new Set(decision.relevantIds)].filter((id) =>
+          candidateIds.has(id),
+        ),
+        ...(result.costUsd !== undefined ? { costUsd: result.costUsd } : {}),
+      };
     },
     async adjudicateSupersession(rawRequest) {
       const request = memorySupersessionInputSchema.parse(rawRequest);
@@ -562,9 +577,12 @@ export function createMemoryAgent(model: PluginModel): MemoryAgent {
         prompt: sessionExtractionPrompt(request),
         maxTokens: 1_000,
       });
-      return extractedMemoriesFromResponse(
-        extractMemoriesResponseSchema.parse(result.object),
-      );
+      return {
+        memories: extractedMemoriesFromResponse(
+          extractMemoriesResponseSchema.parse(result.object),
+        ),
+        ...(result.costUsd !== undefined ? { costUsd: result.costUsd } : {}),
+      };
     },
     async reviewCreateRequest(rawRequest) {
       const request = parseCreateMemoryRequest(rawRequest);

package/src/api.ts

@@ -8,6 +8,7 @@
 import { z } from "zod";
 import {
   pluginApiRouteRequestContextSchema,
+  type PluginConversationEventStats,
   type PluginApiRouteRequestContext,
   type PluginRouteApp,
   type PluginUserPageActor,
@@ -47,10 +48,20 @@ const memoryDashboardDaySchema = z
   })
   .strict();
 
+const memoryCostDaySchema = z
+  .object({
+    costUsd: z.number().finite().nonnegative(),
+    date: z.iso.date(),
+    events: z.number().int().min(0),
+  })
+  .strict();
+
 export const memoryDashboardResponseSchema = z
   .object({
     days: z.array(memoryDashboardDaySchema).length(90),
+    extractionDays: z.array(memoryCostDaySchema).length(90),
     generatedAt: z.iso.datetime(),
+    recallDays: z.array(memoryCostDaySchema).length(90),
     stats: z
       .object({
         active: z.number().int().min(0),
@@ -85,6 +96,7 @@ const memoryListQuerySchema = z
 interface MemoryApiOptions {
   actors(email: string): Promise<PluginUserPageActor[]>;
   db: MemoryDb;
+  eventStats: PluginConversationEventStats;
 }
 
 function json(body: unknown, status = 200): Response {
@@ -94,7 +106,9 @@ function json(body: unknown, status = 200): Response {
   });
 }
 
-function apiMemory(memory: PersonalMemoryRecord): z.output<typeof memoryApiSchema> {
+function apiMemory(
+  memory: PersonalMemoryRecord,
+): z.output<typeof memoryApiSchema> {
   return {
     content: memory.content,
     createdAt: new Date(memory.createdAtMs).toISOString(),
@@ -142,13 +156,23 @@ export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
           isDashboard &&
           (request.method === "GET" || request.method === "HEAD")
         ) {
-          const [stats, days] = await Promise.all([
+          const [stats, days, extractionDays, recallDays] = await Promise.all([
             memories.stats(),
             memories.timeline({ days: 90 }),
+            options.eventStats.costsByDay({
+              days: 90,
+              eventName: "memories_captured",
+            }),
+            options.eventStats.costsByDay({
+              days: 90,
+              eventName: "memories_recalled",
+            }),
           ]);
           const body = memoryDashboardResponseSchema.parse({
             days,
+            extractionDays,
             generatedAt: new Date().toISOString(),
+            recallDays,
             stats,
           });
           return request.method === "HEAD"

package/src/events.ts

@@ -21,8 +21,41 @@ function eventPreview(content: string): string {
   return `${trimmed.slice(0, MAX_EVENT_PREVIEW_CHARS - 3).trimEnd()}...`;
 }
 
-/** Durable transcript event emitted after background memory capture. */
-export const memoriesCapturedEvent = defineConversationEvent({
+const capturedMemoriesSchema = z
+  .object({
+    memories: z.array(capturedMemorySchema).max(100),
+    costUsd: z.number().finite().nonnegative().optional(),
+  })
+  .strict();
+
+const recalledMemoriesSchema = z
+  .object({
+    memories: z.array(z.string().min(1)).max(5),
+    costUsd: z.number().finite().nonnegative().optional(),
+  })
+  .strict();
+
+function renderCapturedMemories(
+  event: z.output<typeof capturedMemoriesSchema>,
+) {
+  const count = event.memories.length;
+  if (count === 0) return undefined;
+  return {
+    icon: "brain" as const,
+    title: count === 1 ? "Memory captured" : "Memories captured",
+    preview:
+      count === 1
+        ? eventPreview(event.memories[0]!.content)
+        : `${count} memories`,
+    details: event.memories.map((memory) => ({
+      title: memory.content,
+      metadata: [memory.kind, memory.scope],
+    })),
+  };
+}
+
+/** Previous stored memory-capture event shape retained for transcript rendering. */
+export const memoriesCapturedEventV1 = defineConversationEvent({
   name: "memories_captured",
   version: 1,
   schema: z
@@ -30,20 +63,24 @@ export const memoriesCapturedEvent = defineConversationEvent({
       memories: z.array(capturedMemorySchema).min(1).max(100),
     })
     .strict(),
-  renderEvent(event) {
-    const count = event.memories.length;
-    return {
-      icon: "brain",
-      title: count === 1 ? "Memory captured" : "Memories captured",
-      preview:
-        count === 1
-          ? eventPreview(event.memories[0]!.content)
-          : `${count} memories`,
-      details: event.memories.map((memory) => ({
-        title: memory.content,
-        metadata: [memory.kind, memory.scope],
-      })),
-    };
+  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;
   },
 });
 

package/src/operational-report.ts

@@ -1,4 +1,7 @@
-import type { PluginOperationalReportContent } from "@sentry/junior-plugin-api";
+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";
@@ -87,9 +90,20 @@ function formatPercent(value: number): string {
   }).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(
@@ -133,6 +147,11 @@ export async function buildMemoryOperationalReport(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(),
@@ -143,6 +162,10 @@ export async function buildMemoryOperationalReport(args: {
         tone: activeCount > 0 ? "good" : "neutral",
         value: formatCount(activeCount),
       },
+      {
+        label: "extraction cost · 30d",
+        value: formatUsd(extractionCostThirtyDays),
+      },
       {
         label: "created · 30d",
         value: formatCount(counts?.createdThirtyDays ?? 0),
@@ -167,6 +190,19 @@ export async function buildMemoryOperationalReport(args: {
       },
     ],
     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,

package/src/personal.ts

@@ -57,7 +57,7 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
       actor,
       source: {
         platform: "slack",
-        type: "priv",
+        visibility: "private",
         teamId: actor.teamId,
         channelId: "DDASHBOARD",
       },
@@ -67,7 +67,7 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
     actor,
     source: {
       platform: "local",
-      type: "priv",
+      visibility: "private",
       conversationId: "local:dashboard:memories",
     },
   };
@@ -75,7 +75,10 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
 
 function decodeCursor(
   value: string | undefined,
-  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
+  input: Pick<
+    ViewerMemoryPageInput,
+    "kind" | "origin" | "query" | "visibility"
+  >,
 ) {
   if (!value) return undefined;
   try {
@@ -98,7 +101,10 @@ function decodeCursor(
 
 function encodeCursor(
   cursor: { createdAtMs: number; id: string },
-  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
+  input: Pick<
+    ViewerMemoryPageInput,
+    "kind" | "origin" | "query" | "visibility"
+  >,
 ): string {
   return Buffer.from(
     JSON.stringify({

package/src/plugin.ts

@@ -14,7 +14,11 @@ import {
 import { processMemorySession } from "./process-session";
 import { createMemoryPromptContributions } from "./recall";
 import { buildMemoryOperationalReport } from "./operational-report";
-import { memoriesCapturedEvent } from "./events";
+import {
+  memoriesCapturedEvent,
+  memoriesCapturedEventV1,
+  memoriesRecalledEvent,
+} from "./events";
 import type { MemoryDb } from "./store";
 import { createMemoryUserPage } from "./user-pages";
 
@@ -101,7 +105,11 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
       ? { structuredModelId: modelId }
       : { structuredModel: "default" },
     packageName: "@sentry/junior-memory",
-    conversationEvents: [memoriesCapturedEvent],
+    conversationEvents: [
+      memoriesCapturedEventV1,
+      memoriesCapturedEvent,
+      memoriesRecalledEvent,
+    ],
     cli: {
       commands: [createMemoryCliCommand()],
     },
@@ -115,8 +123,13 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
     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,
         });
       },
@@ -124,6 +137,7 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
         return createMemoryApi({
           actors: ctx.viewer.actors,
           db: ctx.db as MemoryDb,
+          eventStats: ctx.eventStats,
         });
       },
       tools(ctx) {
@@ -156,6 +170,7 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
           ...(ctx.actor ? { actor: ctx.actor } : {}),
           db: ctx.db as MemoryDb,
           embedder: ctx.embedder,
+          events: ctx.events,
           log: ctx.log,
           maxVectorDistance: recallMaxVectorDistance(options),
           source: ctx.source,

package/src/process-session.ts

@@ -17,6 +17,7 @@ import {
   createMemoryAgent,
   parseExtractedMemory,
   type ExtractedMemory,
+  type MemoryExtractionResult,
 } from "./agent";
 import { MEMORY_KINDS, memoryRuntimeContextSchema } from "./types";
 import { capturedMemory, memoriesCapturedEvent } from "./events";
@@ -28,20 +29,30 @@ const MEMORY_TOOL_NAMES = new Set([
   "searchMemories",
 ]);
 const MEMORY_TASK_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-const extractedMemoryCacheSchema = z.array(
+const extractedMemorySchema = z
+  .object({
+    content: z.string().min(1),
+    expiresAtMs: z.number().finite().nullable(),
+    kind: z.enum(MEMORY_KINDS),
+    evidenceMessageIndices: z
+      .array(z.number().int().nonnegative())
+      .min(1)
+      .max(10),
+  })
+  .strict()
+  .transform(parseExtractedMemory);
+const extractedMemoryCacheSchema = z.union([
   z
     .object({
-      content: z.string().min(1),
-      expiresAtMs: z.number().finite().nullable(),
-      kind: z.enum(MEMORY_KINDS),
-      evidenceMessageIndices: z
-        .array(z.number().int().nonnegative())
-        .min(1)
-        .max(10),
+      costUsd: z.number().finite().nonnegative().optional(),
+      memories: z.array(extractedMemorySchema).max(5),
     })
-    .strict()
-    .transform(parseExtractedMemory),
-);
+    .strict(),
+  z
+    .array(extractedMemorySchema)
+    .max(5)
+    .transform((memories) => ({ memories })),
+]);
 
 /** Where a passively extracted memory may be stored, or dropped when unproven. */
 type MemoryRouteTarget = "drop" | "personal" | "conversation";
@@ -178,10 +189,10 @@ function passiveInput(
   };
 }
 
-async function getTaskMemories(
+async function getTaskExtraction(
   context: PluginTaskContext,
-  extract: () => Promise<ExtractedMemory[]>,
-): Promise<ExtractedMemory[]> {
+  extract: () => Promise<MemoryExtractionResult>,
+): Promise<MemoryExtractionResult> {
   const cacheKey = `memory-extraction:${context.id}`;
   const cached = await context.state.get(cacheKey);
   if (cached !== undefined) {
@@ -191,11 +202,9 @@ async function getTaskMemories(
     }
     await context.state.delete(cacheKey);
   }
-  const memories = await extract();
-  if (memories.length > 0) {
-    await context.state.set(cacheKey, memories, MEMORY_TASK_STATE_TTL_MS);
-  }
-  return memories;
+  const extraction = await extract();
+  await context.state.set(cacheKey, extraction, MEMORY_TASK_STATE_TTL_MS);
+  return extraction;
 }
 
 /**
@@ -251,7 +260,7 @@ export async function processMemorySession(
     supersessionDecider: agent,
   });
   await store.archiveExpiredMemories();
-  const memories = await getTaskMemories(context, async () => {
+  const extraction = await getTaskExtraction(context, async () => {
     const existingMemories = await store.searchMemories({
       limit: 10,
       query: evidenceText,
@@ -265,14 +274,11 @@ export async function processMemorySession(
       runtimeContext,
     });
   });
-  if (memories.length === 0) {
-    return;
-  }
 
   const captured: ReturnType<typeof capturedMemory>[] = [];
-  for (const memory of memories) {
+  for (const memory of extraction.memories) {
     // The routing gate stays even though extraction is also actor-gated:
-    // getTaskMemories caches extraction output for 7 days, so a retry can replay
+    // getTaskExtraction caches extraction output for 7 days, so a retry can replay
     // preference proposals cached before this gate existed.
     const target = routeExtractedMemory(memory, transcript, run);
     if (target === "drop") {
@@ -287,7 +293,12 @@ export async function processMemorySession(
     const result = await store.createMemory(input);
     recordCapturedMemory(captured, result);
   }
-  if (captured.length > 0) {
-    await context.events.emit(memoriesCapturedEvent({ memories: captured }));
-  }
+  await context.events.emit(
+    memoriesCapturedEvent({
+      memories: captured,
+      ...(extraction.costUsd !== undefined
+        ? { costUsd: extraction.costUsd }
+        : {}),
+    }),
+  );
 }