@sentry/junior-memory 0.124.1 → 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/personal-store.d.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { type MemoryDb, type MemoryRecord } from "./store";
 import { type MemoryRuntimeContext } from "./types";
+declare const memoryVisibilitySchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
 declare const personalMemoryCursorSchema: z.ZodObject<{
     createdAtMs: z.ZodNumber;
     id: z.ZodString;
@@ -21,17 +25,23 @@ declare const personalMemoryPageInputSchema: z.ZodObject<{
         explicit: "explicit";
     }>>;
     query: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
 }, z.core.$strict>;
 export type PersonalMemoryCursor = z.output<typeof personalMemoryCursorSchema>;
 export type PersonalMemoryPageInput = z.output<typeof personalMemoryPageInputSchema>;
+export type MemoryVisibility = z.output<typeof memoryVisibilitySchema>;
 export interface PersonalMemoryPage {
     memories: PersonalMemoryRecord[];
     nextCursor?: PersonalMemoryCursor;
 }
-/** Safe provenance attached to one viewer-owned personal memory. */
+/** Safe provenance attached to one viewer-visible memory. */
 export type PersonalMemoryRecord = MemoryRecord & {
     origin: "automatic" | "explicit" | "other";
     sourcePlatform: "local" | "slack";
+    visibility: MemoryVisibility;
 };
 /** Viewer-scoped active memory totals used by the dashboard. */
 export interface PersonalMemoryStats {
@@ -41,36 +51,37 @@ export interface PersonalMemoryStats {
     embedded: number;
     explicit: number;
     knowledge: number;
+    personal: number;
     preference: number;
     procedure: number;
+    public: number;
 }
 /** Viewer-scoped memory creation totals for one UTC calendar day. */
 export interface PersonalMemoryDay {
     date: string;
-    knowledge: number;
-    preference: number;
-    procedure: number;
+    personal: number;
+    public: number;
 }
 /** Expected failure when a viewer does not own the requested memory. */
 export declare class PersonalMemoryNotFoundError extends Error {
     constructor();
 }
-/** Viewer-scoped personal memory operations shared by dashboard and REST. */
+/** Viewer-scoped memory operations shared by dashboard and REST. */
 export interface PersonalMemoryCollection {
     /** Archive one exact personal memory owned by a linked actor. */
     archive(id: string): Promise<MemoryRecord>;
-    /** Read one exact personal memory owned by a linked actor. */
-    get(id: string): Promise<MemoryRecord>;
-    /** List one stable page across every linked personal scope. */
+    /** Read one exact memory visible to a linked actor. */
+    get(id: string): Promise<PersonalMemoryRecord>;
+    /** List one stable page across every authorized viewer scope. */
     list(input: PersonalMemoryPageInput): Promise<PersonalMemoryPage>;
-    /** Summarize active memories across every linked personal scope. */
+    /** Summarize active memories across every authorized viewer scope. */
     stats(): Promise<PersonalMemoryStats>;
-    /** Read memory creation history across every linked personal scope. */
+    /** Read memory creation history across every authorized viewer scope. */
     timeline(input: {
         days: number;
     }): Promise<PersonalMemoryDay[]>;
 }
-/** Build storage operations for every personal scope linked to one viewer. */
+/** Build storage operations for every memory scope linked to one viewer. */
 export declare function createPersonalMemoryCollection(db: MemoryDb, runtimeContexts: MemoryRuntimeContext[], options?: {
     now?: () => number;
 }): PersonalMemoryCollection;

package/dist/personal.d.ts

@@ -1,5 +1,5 @@
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
-import { type PersonalMemoryRecord } from "./personal-store";
+import { type MemoryVisibility, type PersonalMemoryRecord } from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
 import type { MemoryKind } from "./types";
 export interface ViewerMemoryPage {
@@ -12,15 +12,17 @@ export interface ViewerMemoryPageInput {
     limit: number;
     origin?: "automatic" | "explicit";
     query?: string;
+    visibility?: MemoryVisibility;
 }
 export declare class InvalidMemoryCursorError extends Error {
     constructor();
 }
 export { PersonalMemoryNotFoundError } from "./personal-store";
-/** Build personal-memory operations authorized by a viewer's linked actors. */
+export type { MemoryVisibility, PersonalMemoryRecord } from "./personal-store";
+/** Build viewer memory operations authorized by a viewer's linked actors. */
 export declare function createViewerMemories(db: MemoryDb, actors: PluginUserPageActor[]): {
     archive(id: string): Promise<MemoryRecord>;
-    get(id: string): Promise<MemoryRecord>;
+    get(id: string): Promise<PersonalMemoryRecord>;
     list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage>;
     stats(): Promise<import("./personal-store").PersonalMemoryStats>;
     timeline(input: {

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/dist/user-pages.d.ts

@@ -1,4 +1,4 @@
-/** Project viewer-owned memories into Junior's core-rendered user page. */
+/** Project viewer-visible memories into Junior's core-rendered user page. */
 import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
-/** Create the interactive personal Memories dashboard page. */
+/** Create the interactive Memories dashboard page. */
 export declare function createMemoryUserPage(): PluginUserPageDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.124.1",
+  "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.1"
+    "@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

@@ -1,21 +1,24 @@
 /**
- * Authenticated REST resources for personal memories.
+ * Authenticated REST resources for viewer-visible memories.
  *
  * HTTP identity is one verified viewer. Linked platform actors are resolved
- * behind the route boundary and used only to authorize personal scopes.
+ * behind the route boundary and used only to authorize personal and public
+ * workspace scopes.
  */
 import { z } from "zod";
 import {
   pluginApiRouteRequestContextSchema,
+  type PluginConversationEventStats,
   type PluginApiRouteRequestContext,
   type PluginRouteApp,
   type PluginUserPageActor,
 } from "@sentry/junior-plugin-api";
-import type { MemoryDb, MemoryRecord } from "./store";
+import type { MemoryDb } from "./store";
 import {
   createViewerMemories,
   InvalidMemoryCursorError,
   PersonalMemoryNotFoundError,
+  type PersonalMemoryRecord,
 } from "./personal";
 
 export const memoryApiSchema = z
@@ -26,6 +29,7 @@ export const memoryApiSchema = z
     id: z.string().min(1),
     kind: z.enum(["preference", "procedure", "knowledge"]),
     observedAt: z.iso.datetime(),
+    visibility: z.enum(["private", "public"]),
   })
   .strict();
 
@@ -39,15 +43,23 @@ export const memoryListResponseSchema = z
 const memoryDashboardDaySchema = z
   .object({
     date: z.iso.date(),
-    knowledge: z.number().int().min(0),
-    preference: z.number().int().min(0),
-    procedure: z.number().int().min(0),
+    personal: z.number().int().min(0),
+    public: z.number().int().min(0),
+  })
+  .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({
@@ -57,8 +69,10 @@ export const memoryDashboardResponseSchema = z
         embedded: z.number().int().min(0),
         explicit: z.number().int().min(0),
         knowledge: z.number().int().min(0),
+        personal: z.number().int().min(0),
         preference: z.number().int().min(0),
         procedure: z.number().int().min(0),
+        public: z.number().int().min(0),
       })
       .strict(),
   })
@@ -81,6 +95,7 @@ const memoryListQuerySchema = z
 interface MemoryApiOptions {
   actors(email: string): Promise<PluginUserPageActor[]>;
   db: MemoryDb;
+  eventStats: PluginConversationEventStats;
 }
 
 function json(body: unknown, status = 200): Response {
@@ -90,7 +105,9 @@ function json(body: unknown, status = 200): Response {
   });
 }
 
-function apiMemory(memory: MemoryRecord): z.output<typeof memoryApiSchema> {
+function apiMemory(
+  memory: PersonalMemoryRecord,
+): z.output<typeof memoryApiSchema> {
   return {
     content: memory.content,
     createdAt: new Date(memory.createdAtMs).toISOString(),
@@ -100,6 +117,7 @@ function apiMemory(memory: MemoryRecord): z.output<typeof memoryApiSchema> {
     id: memory.id,
     kind: memory.kind,
     observedAt: new Date(memory.observedAtMs).toISOString(),
+    visibility: memory.visibility,
   };
 }
 
@@ -113,7 +131,7 @@ function viewerEmail(
   return parsed.data.auth.user.email?.trim().toLowerCase() || undefined;
 }
 
-/** Create the authenticated personal-memory REST app. */
+/** Create the authenticated viewer-memory REST app. */
 export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
   return {
     async fetch(request, context) {
@@ -137,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,