@sentry/junior-memory 0.124.2 → 0.125.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

@@ -141,6 +141,7 @@ export interface MemoryEmbeddingProvider {
     embedTexts(input: {
         texts: string[];
     }): Promise<{
+        costUsd?: number;
         dimensions: number;
         model: string;
         provider: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.124.2",
+  "version": "0.125.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.125.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,9 +48,18 @@ const memoryDashboardDaySchema = z
   })
   .strict();
 
+const memoryExtractionDaySchema = 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(memoryExtractionDaySchema).length(90),
     generatedAt: z.iso.datetime(),
     stats: z
       .object({
@@ -85,6 +95,7 @@ const memoryListQuerySchema = z
 interface MemoryApiOptions {
   actors(email: string): Promise<PluginUserPageActor[]>;
   db: MemoryDb;
+  eventStats: PluginConversationEventStats;
 }
 
 function json(body: unknown, status = 200): Response {
@@ -94,7 +105,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,12 +155,17 @@ export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
           isDashboard &&
           (request.method === "GET" || request.method === "HEAD")
         ) {
-          const [stats, days] = await Promise.all([
+          const [stats, days, extractionDays] = await Promise.all([
             memories.stats(),
             memories.timeline({ days: 90 }),
+            options.eventStats.costsByDay({
+              days: 90,
+              eventName: "memories_captured",
+            }),
           ]);
           const body = memoryDashboardResponseSchema.parse({
             days,
+            extractionDays,
             generatedAt: new Date().toISOString(),
             stats,
           });

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/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 }
+        : {}),
+    }),
+  );
 }

package/src/recall.ts

@@ -2,11 +2,13 @@ import {
   definePromptContext,
   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 { MemoryAgent, MemoryRecallResult } from "./agent";
+import { memoriesRecalledEvent } from "./events";
 import {
   createMemoryStore,
   type MemoryDb,
@@ -25,6 +27,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;
@@ -101,6 +104,28 @@ function renderMemoryPrompt(memories: RecalledMemory[]): string {
   ].join("\n");
 }
 
+function addUsd(
+  left: number | undefined,
+  right: number | undefined,
+): number | undefined {
+  if (left === undefined) return right;
+  if (right === undefined) return left;
+  return Math.round((left + right) * 1e12) / 1e12;
+}
+
+async function emitRecallOutcome(args: {
+  costUsd?: number;
+  events?: PluginConversationEvents;
+  memories: string[];
+}): Promise<void> {
+  await args.events?.emit(
+    memoriesRecalledEvent({
+      memories: args.memories,
+      ...(args.costUsd !== undefined ? { costUsd: args.costUsd } : {}),
+    }),
+  );
+}
+
 const memoryRecallContext = definePromptContext({
   kind: "recall",
   version: 1,
@@ -122,8 +147,19 @@ export async function createMemoryPromptContributions(
     ...(context.actor ? { actor: context.actor } : {}),
     source: context.source,
   });
+  let embeddingCostUsd: number | undefined;
+  const sourceEmbedder = context.embedder;
+  const embedder = sourceEmbedder
+    ? {
+        async embedTexts(input: { texts: string[] }) {
+          const result = await sourceEmbedder.embedTexts(input);
+          embeddingCostUsd = addUsd(embeddingCostUsd, result.costUsd);
+          return result;
+        },
+      }
+    : undefined;
   const candidates = await createMemoryStore(context.db, runtimeContext, {
-    ...(context.embedder ? { embedder: context.embedder } : {}),
+    ...(embedder ? { embedder } : {}),
     ...(context.maxVectorDistance !== undefined
       ? { maxVectorDistance: context.maxVectorDistance }
       : {}),
@@ -132,11 +168,16 @@ export async function createMemoryPromptContributions(
     limit: RECALL_CANDIDATE_LIMIT,
   });
   if (candidates.length === 0) {
+    await emitRecallOutcome({
+      ...(embeddingCostUsd !== undefined ? { costUsd: embeddingCostUsd } : {}),
+      events: context.events,
+      memories: [],
+    });
     return undefined;
   }
-  let relevantIds: string[];
+  let recall: MemoryRecallResult;
   try {
-    relevantIds = await context.agent.selectRelevantMemories({
+    recall = await context.agent.selectRelevantMemories({
       candidates: candidates.map(({ content, id }) => ({ content, id })),
       userRequest: context.text,
     });
@@ -149,11 +190,17 @@ export async function createMemoryPromptContributions(
   const candidatesById = new Map(
     candidates.map((memory) => [memory.id, memory]),
   );
-  const relevant = relevantIds
+  const relevant = recall.relevantIds
     .map((id) => candidatesById.get(id))
     .filter((memory): memory is MemoryRecord => memory !== undefined)
     .slice(0, DEFAULT_RECALL_LIMIT);
   const selected = selectPromptMemories(relevant);
+  const costUsd = addUsd(embeddingCostUsd, recall.costUsd);
+  await emitRecallOutcome({
+    ...(costUsd !== undefined ? { costUsd } : {}),
+    events: context.events,
+    memories: selected.map(({ id }) => id),
+  });
   if (selected.length === 0) {
     return undefined;
   }

package/src/store.ts

@@ -180,6 +180,7 @@ const embeddingVectorSchema = z
   .length(MEMORY_EMBEDDING_DIMENSIONS);
 const embeddingResultSchema = z
   .object({
+    costUsd: z.number().finite().nonnegative().optional(),
     dimensions: z.literal(MEMORY_EMBEDDING_DIMENSIONS),
     model: nonEmptyStringSchema,
     provider: nonEmptyStringSchema,
@@ -272,6 +273,7 @@ export interface ArchiveExpiredMemoriesResult {
 export interface MemoryEmbeddingProvider {
   /** Embed normalized memory text for derived vector retrieval. */
   embedTexts(input: { texts: string[] }): Promise<{
+    costUsd?: number;
     dimensions: number;
     model: string;
     provider: string;

package/src/tools.ts

@@ -420,6 +420,7 @@ function memoryToolResult<TData extends Record<string, unknown>>(
 /** Create a tool that submits an explicit memory candidate for storage. */
 export function createMemoryCreateTool(context: MemoryCreateToolContext) {
   return definePluginTool({
+    approvalMode: "approve",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,