@sentry/junior-memory 0.124.2 → 0.125.0

package/README.md

@@ -15,7 +15,9 @@ exported types, tools, and tests are authoritative.
   inspection.
 - The dashboard exposes a searchable, paginated **Memories** user page for
   personal memories owned by actors linked to the signed-in viewer. Its
-  **Forget** action archives the selected memory.
+  **Forget** action archives the selected memory. The overview charts global
+  passive-extraction cost from the durable `memory/memories_captured` events;
+  the System plugin report uses the same event-cost feed.
 - Authenticated REST clients can list and search personal memories through
   `GET /api/plugins/memory/memories`, read one through
   `GET /api/plugins/memory/memories/:id`, and archive one through
@@ -55,6 +57,10 @@ exported types, tools, and tests are authoritative.
   learning.
 - Passive extraction creates only durable, reusable facts—not transient tasks,
   conversation summaries, secrets, or speculative interpretation.
+- Every completed passive extraction emits the namespaced
+  `memory/memories_captured` conversation event with its best-effort model cost.
+  Empty extraction outcomes remain durable for reporting but do not produce a
+  transcript row.
 - Candidate review resolves duplicates and supersession before activation.
 - Search combines independently ranked vector and PostgreSQL full-text matches
   with reciprocal rank fusion; provider-specific raw scores are never added
@@ -62,6 +68,10 @@ exported types, tools, and tests are authoritative.
 - Automatic recall retrieves a broad candidate window, then uses the
   memory-owned relevance model to admit at most five directly useful memories.
   An empty result contributes no filler prompt text.
+- Every completed automatic recall attempt emits an invisible, namespaced
+  `memory/memories_recalled` conversation event with the admitted memory IDs
+  and best-effort embedding and relevance-model cost, including retrievals that
+  find no candidates and decisions that admit no memories.
 - Automatic recall degrades to no prompt contribution when relevance selection
   fails. Review, extraction, and write failures still fail their owning
   hook/task without corrupting existing memory state.

package/dist/agent.d.ts

@@ -183,12 +183,22 @@ export type MemoryRecallInput = z.output<typeof memoryRecallInputSchema>;
 export type CreateMemoryRequest = z.output<typeof createMemoryRequestSchema>;
 export type ExtractSessionRequest = z.output<typeof extractSessionRequestSchema>;
 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[];
+    selectRelevantMemories(request: MemoryRecallInput): Promise<MemoryRecallResult> | MemoryRecallResult;
     /** Classify a new preference against related active preferences. */
     adjudicateSupersession(request: MemorySupersessionInput): Promise<MemorySupersessionDecision> | MemorySupersessionDecision;
-    extractSessionMemories(request: ExtractSessionRequest): Promise<ExtractedMemory[]> | ExtractedMemory[];
+    extractSessionMemories(request: ExtractSessionRequest): Promise<MemoryExtractionResult> | MemoryExtractionResult;
     reviewCreateRequest(request: CreateMemoryRequest): Promise<MemoryReview> | MemoryReview;
 }
 /** Create the memory-owned agent that reviews, extracts, and recalls memories. */

package/dist/api.d.ts

@@ -6,7 +6,7 @@
  * workspace scopes.
  */
 import { z } from "zod";
-import { type PluginRouteApp, type PluginUserPageActor } from "@sentry/junior-plugin-api";
+import { type PluginConversationEventStats, type PluginRouteApp, type PluginUserPageActor } from "@sentry/junior-plugin-api";
 import type { MemoryDb } from "./store";
 export declare const memoryApiSchema: z.ZodObject<{
     content: z.ZodString;
@@ -49,6 +49,11 @@ export declare const memoryDashboardResponseSchema: z.ZodObject<{
         personal: z.ZodNumber;
         public: z.ZodNumber;
     }, z.core.$strict>>;
+    extractionDays: z.ZodArray<z.ZodObject<{
+        costUsd: z.ZodNumber;
+        date: z.ZodISODate;
+        events: z.ZodNumber;
+    }, z.core.$strict>>;
     generatedAt: z.ZodISODateTime;
     stats: z.ZodObject<{
         active: z.ZodNumber;
@@ -69,6 +74,7 @@ export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 interface MemoryApiOptions {
     actors(email: string): Promise<PluginUserPageActor[]>;
     db: MemoryDb;
+    eventStats: PluginConversationEventStats;
 }
 /** Create the authenticated viewer-memory REST app. */
 export declare function createMemoryApi(options: MemoryApiOptions): PluginRouteApp;

package/dist/events.d.ts

@@ -1,5 +1,15 @@
 import type { MemoryRecord } from "./store";
-/** Durable transcript event emitted after background memory capture. */
+/** Previous stored memory-capture event shape retained for transcript rendering. */
+export declare const memoriesCapturedEventV1: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
+    memories: {
+        content: string;
+        id: string;
+        kind: "preference" | "procedure" | "knowledge";
+        observedAtMs: number;
+        scope: "personal" | "conversation";
+    }[];
+}>;
+/** Durable outcome emitted after every completed passive memory extraction. */
 export declare const memoriesCapturedEvent: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
     memories: {
         content: string;
@@ -8,6 +18,12 @@ export declare const memoriesCapturedEvent: import("@sentry/junior-plugin-api").
         observedAtMs: number;
         scope: "personal" | "conversation";
     }[];
+    costUsd?: number | undefined;
+}>;
+/** Durable outcome emitted after one completed automatic recall attempt. */
+export declare const memoriesRecalledEvent: import("@sentry/junior-plugin-api").DefinedConversationEvent<{
+    memories: string[];
+    costUsd?: number | undefined;
 }>;
 /** Select the stable, safe memory fields retained in conversation history. */
 export declare function capturedMemory(memory: MemoryRecord): {

package/dist/index.js

@@ -397,6 +397,7 @@ var memoryRecordSchema = z2.object({
 }).strict();
 var embeddingVectorSchema = z2.array(numberSchema).length(MEMORY_EMBEDDING_DIMENSIONS);
 var embeddingResultSchema = z2.object({
+  costUsd: z2.number().finite().nonnegative().optional(),
   dimensions: z2.literal(MEMORY_EMBEDDING_DIMENSIONS),
   model: nonEmptyStringSchema2,
   provider: nonEmptyStringSchema2,
@@ -1680,9 +1681,12 @@ function createMemoryAgent(model) {
       });
       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 !== void 0 ? { costUsd: result.costUsd } : {}
+      };
     },
     async adjudicateSupersession(rawRequest) {
       const request = memorySupersessionInputSchema.parse(rawRequest);
@@ -1702,9 +1706,12 @@ function createMemoryAgent(model) {
         prompt: sessionExtractionPrompt(request),
         maxTokens: 1e3
       });
-      return extractedMemoriesFromResponse(
-        extractMemoriesResponseSchema.parse(result.object)
-      );
+      return {
+        memories: extractedMemoriesFromResponse(
+          extractMemoriesResponseSchema.parse(result.object)
+        ),
+        ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : {}
+      };
     },
     async reviewCreateRequest(rawRequest) {
       const request = parseCreateMemoryRequest(rawRequest);
@@ -2170,8 +2177,14 @@ var memoryDashboardDaySchema = z6.object({
   personal: z6.number().int().min(0),
   public: z6.number().int().min(0)
 }).strict();
+var memoryExtractionDaySchema = z6.object({
+  costUsd: z6.number().finite().nonnegative(),
+  date: z6.iso.date(),
+  events: z6.number().int().min(0)
+}).strict();
 var memoryDashboardResponseSchema = z6.object({
   days: z6.array(memoryDashboardDaySchema).length(90),
+  extractionDays: z6.array(memoryExtractionDaySchema).length(90),
   generatedAt: z6.iso.datetime(),
   stats: z6.object({
     active: z6.number().int().min(0),
@@ -2233,12 +2246,17 @@ function createMemoryApi(options) {
       const memories = createViewerMemories(options.db, actors);
       try {
         if (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 })
+            memories.timeline({ days: 90 }),
+            options.eventStats.costsByDay({
+              days: 90,
+              eventName: "memories_captured"
+            })
           ]);
           const body = memoryDashboardResponseSchema.parse({
             days,
+            extractionDays,
             generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
             stats
           });
@@ -2679,6 +2697,7 @@ function memoryToolResult(target, data) {
 }
 function createMemoryCreateTool(context) {
   return definePluginTool({
+    approvalMode: "approve",
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -2858,23 +2877,47 @@ function eventPreview(content) {
   if (trimmed.length <= MAX_EVENT_PREVIEW_CHARS) return trimmed;
   return `${trimmed.slice(0, MAX_EVENT_PREVIEW_CHARS - 3).trimEnd()}...`;
 }
-var memoriesCapturedEvent = defineConversationEvent({
+var capturedMemoriesSchema = z8.object({
+  memories: z8.array(capturedMemorySchema).max(100),
+  costUsd: z8.number().finite().nonnegative().optional()
+}).strict();
+var recalledMemoriesSchema = z8.object({
+  memories: z8.array(z8.string().min(1)).max(5),
+  costUsd: z8.number().finite().nonnegative().optional()
+}).strict();
+function renderCapturedMemories(event) {
+  const count = event.memories.length;
+  if (count === 0) return void 0;
+  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]
+    }))
+  };
+}
+var memoriesCapturedEventV1 = defineConversationEvent({
   name: "memories_captured",
   version: 1,
   schema: z8.object({
     memories: z8.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
+});
+var memoriesCapturedEvent = defineConversationEvent({
+  name: "memories_captured",
+  version: 2,
+  schema: capturedMemoriesSchema,
+  renderEvent: renderCapturedMemories
+});
+var memoriesRecalledEvent = defineConversationEvent({
+  name: "memories_recalled",
+  version: 1,
+  schema: recalledMemoriesSchema,
+  renderEvent() {
+    return void 0;
   }
 });
 function capturedMemory(memory) {
@@ -2895,14 +2938,19 @@ var MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
   "searchMemories"
 ]);
 var MEMORY_TASK_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var extractedMemoryCacheSchema = z9.array(
+var extractedMemorySchema2 = z9.object({
+  content: z9.string().min(1),
+  expiresAtMs: z9.number().finite().nullable(),
+  kind: z9.enum(MEMORY_KINDS),
+  evidenceMessageIndices: z9.array(z9.number().int().nonnegative()).min(1).max(10)
+}).strict().transform(parseExtractedMemory);
+var extractedMemoryCacheSchema = z9.union([
   z9.object({
-    content: z9.string().min(1),
-    expiresAtMs: z9.number().finite().nullable(),
-    kind: z9.enum(MEMORY_KINDS),
-    evidenceMessageIndices: z9.array(z9.number().int().nonnegative()).min(1).max(10)
-  }).strict().transform(parseExtractedMemory)
-);
+    costUsd: z9.number().finite().nonnegative().optional(),
+    memories: z9.array(extractedMemorySchema2).max(5)
+  }).strict(),
+  z9.array(extractedMemorySchema2).max(5).transform((memories) => ({ memories }))
+]);
 function recordCapturedMemory(captured, result) {
   const supersededIds = new Set(result.supersededIds ?? []);
   for (let index2 = captured.length - 1; index2 >= 0; index2 -= 1) {
@@ -2969,7 +3017,7 @@ function passiveInput(sessionId, memory, sourceKey2, target) {
     ...memory.expiresAtMs !== null ? { expiresAtMs: memory.expiresAtMs } : {}
   };
 }
-async function getTaskMemories(context, extract) {
+async function getTaskExtraction(context, extract) {
   const cacheKey = `memory-extraction:${context.id}`;
   const cached = await context.state.get(cacheKey);
   if (cached !== void 0) {
@@ -2979,11 +3027,9 @@ async function getTaskMemories(context, extract) {
     }
     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;
 }
 async function processMemorySession(context) {
   const run = await context.run.load();
@@ -3015,7 +3061,7 @@ async function processMemorySession(context) {
     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
@@ -3029,11 +3075,8 @@ async function processMemorySession(context) {
       runtimeContext: runtimeContext2
     });
   });
-  if (memories.length === 0) {
-    return;
-  }
   const captured = [];
-  for (const memory of memories) {
+  for (const memory of extraction.memories) {
     const target = routeExtractedMemory(memory, transcript, run);
     if (target === "drop") {
       continue;
@@ -3047,9 +3090,12 @@ async function processMemorySession(context) {
     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 !== void 0 ? { costUsd: extraction.costUsd } : {}
+    })
+  );
 }
 
 // src/recall.ts
@@ -3113,6 +3159,19 @@ function renderMemoryPrompt(memories) {
     "Treat these as possibly stale context. Current user instructions and repository evidence take priority."
   ].join("\n");
 }
+function addUsd(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.round((left + right) * 1e12) / 1e12;
+}
+async function emitRecallOutcome(args) {
+  await args.events?.emit(
+    memoriesRecalledEvent({
+      memories: args.memories,
+      ...args.costUsd !== void 0 ? { costUsd: args.costUsd } : {}
+    })
+  );
+}
 var memoryRecallContext = definePromptContext({
   kind: "recall",
   version: 1,
@@ -3128,19 +3187,33 @@ async function createMemoryPromptContributions(context) {
     ...context.actor ? { actor: context.actor } : {},
     source: context.source
   });
+  let embeddingCostUsd;
+  const sourceEmbedder = context.embedder;
+  const embedder = sourceEmbedder ? {
+    async embedTexts(input) {
+      const result = await sourceEmbedder.embedTexts(input);
+      embeddingCostUsd = addUsd(embeddingCostUsd, result.costUsd);
+      return result;
+    }
+  } : void 0;
   const candidates = await createMemoryStore(context.db, runtimeContext2, {
-    ...context.embedder ? { embedder: context.embedder } : {},
+    ...embedder ? { embedder } : {},
     ...context.maxVectorDistance !== void 0 ? { maxVectorDistance: context.maxVectorDistance } : {}
   }).recallMemories({
     query: context.text,
     limit: RECALL_CANDIDATE_LIMIT
   });
   if (candidates.length === 0) {
+    await emitRecallOutcome({
+      ...embeddingCostUsd !== void 0 ? { costUsd: embeddingCostUsd } : {},
+      events: context.events,
+      memories: []
+    });
     return void 0;
   }
-  let relevantIds;
+  let recall;
   try {
-    relevantIds = await context.agent.selectRelevantMemories({
+    recall = await context.agent.selectRelevantMemories({
       candidates: candidates.map(({ content, id }) => ({ content, id })),
       userRequest: context.text
     });
@@ -3151,8 +3224,14 @@ async function createMemoryPromptContributions(context) {
   const candidatesById = new Map(
     candidates.map((memory) => [memory.id, memory])
   );
-  const relevant = relevantIds.map((id) => candidatesById.get(id)).filter((memory) => memory !== void 0).slice(0, DEFAULT_RECALL_LIMIT);
+  const relevant = recall.relevantIds.map((id) => candidatesById.get(id)).filter((memory) => memory !== void 0).slice(0, DEFAULT_RECALL_LIMIT);
   const selected = selectPromptMemories(relevant);
+  const costUsd = addUsd(embeddingCostUsd, recall.costUsd);
+  await emitRecallOutcome({
+    ...costUsd !== void 0 ? { costUsd } : {},
+    events: context.events,
+    memories: selected.map(({ id }) => id)
+  });
   if (selected.length === 0) {
     return void 0;
   }
@@ -3231,6 +3310,15 @@ function formatPercent(value) {
     style: "percent"
   }).format(value);
 }
+function formatUsd(value) {
+  const maximumFractionDigits = value > 0 && value < 0.01 ? 4 : 2;
+  return new Intl.NumberFormat("en-US", {
+    currency: "USD",
+    maximumFractionDigits,
+    minimumFractionDigits: 2,
+    style: "currency"
+  }).format(value);
+}
 async function buildMemoryOperationalReport(args) {
   const active = and4(
     isNull3(juniorMemoryMemories.archivedAtMs),
@@ -3265,6 +3353,11 @@ 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(),
     title: "Memory",
@@ -3274,6 +3367,10 @@ async function buildMemoryOperationalReport(args) {
         tone: activeCount > 0 ? "good" : "neutral",
         value: formatCount(activeCount)
       },
+      {
+        label: "extraction cost \xB7 30d",
+        value: formatUsd(extractionCostThirtyDays)
+      },
       {
         label: "created \xB7 30d",
         value: formatCount(counts?.createdThirtyDays ?? 0)
@@ -3293,6 +3390,19 @@ 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,
@@ -3453,7 +3563,11 @@ function memoryPlugin(options = {}) {
     },
     model: modelId ? { structuredModelId: modelId } : { structuredModel: "default" },
     packageName: "@sentry/junior-memory",
-    conversationEvents: [memoriesCapturedEvent],
+    conversationEvents: [
+      memoriesCapturedEventV1,
+      memoriesCapturedEvent,
+      memoriesRecalledEvent
+    ],
     cli: {
       commands: [createMemoryCliCommand()]
     },
@@ -3467,15 +3581,21 @@ function memoryPlugin(options = {}) {
     userPages: [createMemoryUserPage()],
     hooks: {
       async operationalReport(ctx) {
+        const extractionDays = await ctx.eventStats.costsByDay({
+          days: 90,
+          eventName: "memories_captured"
+        });
         return await buildMemoryOperationalReport({
           db: ctx.db,
+          extractionDays,
           nowMs: ctx.nowMs
         });
       },
       apiRoutes(ctx) {
         return createMemoryApi({
           actors: ctx.viewer.actors,
-          db: ctx.db
+          db: ctx.db,
+          eventStats: ctx.eventStats
         });
       },
       tools(ctx) {
@@ -3508,6 +3628,7 @@ function memoryPlugin(options = {}) {
           ...ctx.actor ? { actor: ctx.actor } : {},
           db: ctx.db,
           embedder: ctx.embedder,
+          events: ctx.events,
           log: ctx.log,
           maxVectorDistance: recallMaxVectorDistance(options),
           source: ctx.source,