@sentry/junior-memory 0.124.1 → 0.125.0

package/src/personal-store.ts

@@ -1,8 +1,8 @@
 /**
- * SQL operations over personal memories owned by one authenticated viewer.
+ * SQL operations over memories visible to one authenticated viewer.
  *
  * A viewer may resolve to several runtime actors. This store combines their
- * personal scopes without treating one actor as the canonical identity.
+ * personal scopes with authorized public workspace conversation scopes.
  */
 import { and, asc, desc, eq, gt, ilike, like, lt, or, sql } from "drizzle-orm";
 import { z } from "zod";
@@ -18,6 +18,7 @@ import {
 import { MEMORY_KINDS, type MemoryRuntimeContext } from "./types";
 
 const nonEmptyStringSchema = z.string().min(1);
+const memoryVisibilitySchema = z.enum(["private", "public"]);
 const personalMemoryCursorSchema = z
   .object({
     createdAtMs: z.number().finite(),
@@ -31,6 +32,7 @@ const personalMemoryPageInputSchema = z
     limit: z.number().int().min(1).max(50),
     origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
+    visibility: memoryVisibilitySchema.optional(),
   })
   .strict();
 const personalMemoryTimelineInputSchema = z
@@ -46,15 +48,18 @@ 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. */
@@ -65,16 +70,17 @@ 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. */
@@ -85,17 +91,17 @@ export class PersonalMemoryNotFoundError extends Error {
   }
 }
 
-/** 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[]>;
 }
 
@@ -112,7 +118,30 @@ function personalScopes(
   ];
 }
 
-function personalScopePredicate(scopes: ResolvedMemoryScope[]) {
+/** Public workspace conversation scopes authorized by the viewer's Slack teams. */
+function publicWorkspaceScopes(
+  runtimeContexts: MemoryRuntimeContext[],
+): ResolvedMemoryScope[] {
+  return [
+    ...new Map(
+      runtimeContexts.flatMap((context) => {
+        if (context.source.platform !== "slack" || !context.actor) {
+          return [];
+        }
+        if (context.actor.platform !== "slack") {
+          return [];
+        }
+        const scope: ResolvedMemoryScope = {
+          scope: "conversation",
+          scopeKey: `slack:${context.actor.teamId}`,
+        };
+        return [[`${scope.scope}:${scope.scopeKey}`, scope] as const];
+      }),
+    ).values(),
+  ];
+}
+
+function scopePredicate(scopes: ResolvedMemoryScope[]) {
   if (scopes.length === 0) return undefined;
   return or(
     ...scopes.map((scope) =>
@@ -148,30 +177,67 @@ function memoryOrigin(
   return "other";
 }
 
+function memoryVisibility(
+  scope: MemoryRecord["scope"],
+): PersonalMemoryRecord["visibility"] {
+  return scope === "personal" ? "private" : "public";
+}
+
 function personalMemoryRecord(
   row: typeof juniorMemoryMemories.$inferSelect,
 ): PersonalMemoryRecord {
+  const memory = parseMemoryRow(row);
   return {
-    ...parseMemoryRow(row),
+    ...memory,
     origin: memoryOrigin(row.idempotencyKey),
     sourcePlatform: row.sourcePlatform,
+    visibility: memoryVisibility(memory.scope),
+  };
+}
+
+function emptyStats(): PersonalMemoryStats {
+  return {
+    active: 0,
+    automatic: 0,
+    createdThirtyDays: 0,
+    embedded: 0,
+    explicit: 0,
+    knowledge: 0,
+    personal: 0,
+    preference: 0,
+    procedure: 0,
+    public: 0,
   };
 }
 
-/** Build storage operations for every personal scope linked to one viewer. */
+/** Build storage operations for every memory scope linked to one viewer. */
 export function createPersonalMemoryCollection(
   db: MemoryDb,
   runtimeContexts: MemoryRuntimeContext[],
   options: { now?: () => number } = {},
 ): PersonalMemoryCollection {
-  const scopes = personalScopes(runtimeContexts);
+  const privateScopes = personalScopes(runtimeContexts);
+  const publicScopes = publicWorkspaceScopes(runtimeContexts);
+  const allScopes = [...privateScopes, ...publicScopes];
   const getNowMs = () => options.now?.() ?? Date.now();
 
+  function scopesForVisibility(
+    visibility: MemoryVisibility | undefined,
+  ): ResolvedMemoryScope[] {
+    if (visibility === "private") return privateScopes;
+    if (visibility === "public") return publicScopes;
+    return allScopes;
+  }
+
   return {
     async archive(id) {
       const memoryId = nonEmptyStringSchema.parse(id);
       const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      // Forget is personal-only; public workspace memories stay shared.
+      const predicate = activeVisiblePredicate({
+        nowMs,
+        scopes: privateScopes,
+      });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -195,7 +261,7 @@ export function createPersonalMemoryCollection(
     async get(id) {
       const memoryId = nonEmptyStringSchema.parse(id);
       const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      const predicate = activeVisiblePredicate({ nowMs, scopes: allScopes });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -207,12 +273,13 @@ export function createPersonalMemoryCollection(
       if (!rows[0]) {
         throw new PersonalMemoryNotFoundError();
       }
-      return parseMemoryRow(rows[0]);
+      return personalMemoryRecord(rows[0]);
     },
 
     async list(input) {
       input = personalMemoryPageInputSchema.parse(input);
       const nowMs = getNowMs();
+      const scopes = scopesForVisibility(input.visibility);
       await archiveExpiredMemoryBatch({ db, nowMs, scopes });
       const active = activeVisiblePredicate({ nowMs, scopes });
       if (!active) {
@@ -275,19 +342,10 @@ export function createPersonalMemoryCollection(
 
     async stats() {
       const nowMs = getNowMs();
-      await archiveExpiredMemoryBatch({ db, nowMs, scopes });
-      const active = activeVisiblePredicate({ nowMs, scopes });
+      await archiveExpiredMemoryBatch({ db, nowMs, scopes: allScopes });
+      const active = activeVisiblePredicate({ nowMs, scopes: allScopes });
       if (!active) {
-        return {
-          active: 0,
-          automatic: 0,
-          createdThirtyDays: 0,
-          embedded: 0,
-          explicit: 0,
-          knowledge: 0,
-          preference: 0,
-          procedure: 0,
-        };
+        return emptyStats();
       }
       const [counts] = await db
         .select({
@@ -312,6 +370,10 @@ export function createPersonalMemoryCollection(
             sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
               Number,
             ),
+          personal:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+              Number,
+            ),
           preference:
             sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
               Number,
@@ -320,6 +382,10 @@ export function createPersonalMemoryCollection(
             sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
               Number,
             ),
+          public:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+              Number,
+            ),
         })
         .from(juniorMemoryMemories)
         .leftJoin(
@@ -334,8 +400,10 @@ export function createPersonalMemoryCollection(
         embedded: counts?.embedded ?? 0,
         explicit: counts?.explicit ?? 0,
         knowledge: counts?.knowledge ?? 0,
+        personal: counts?.personal ?? 0,
         preference: counts?.preference ?? 0,
         procedure: counts?.procedure ?? 0,
+        public: counts?.public ?? 0,
       };
     },
 
@@ -343,13 +411,12 @@ export function createPersonalMemoryCollection(
       input = personalMemoryTimelineInputSchema.parse(input);
       const todayMs = Date.parse(`${utcDate(getNowMs())}T00:00:00.000Z`);
       const startMs = todayMs - (input.days - 1) * DAY_MS;
-      const ownership = personalScopePredicate(scopes);
+      const ownership = scopePredicate(allScopes);
       if (!ownership) {
         return Array.from({ length: input.days }, (_, index) => ({
           date: utcDate(startMs + index * DAY_MS),
-          knowledge: 0,
-          preference: 0,
-          procedure: 0,
+          personal: 0,
+          public: 0,
         }));
       }
       const rows = await db
@@ -357,16 +424,12 @@ export function createPersonalMemoryCollection(
           date: sql<string>`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
             "date",
           ),
-          knowledge:
-            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+          personal:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
               Number,
             ),
-          preference:
-            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
-              Number,
-            ),
-          procedure:
-            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+          public:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
               Number,
             ),
         })
@@ -383,9 +446,8 @@ export function createPersonalMemoryCollection(
         const row = byDate.get(date);
         return {
           date,
-          knowledge: row?.knowledge ?? 0,
-          preference: row?.preference ?? 0,
-          procedure: row?.procedure ?? 0,
+          personal: row?.personal ?? 0,
+          public: row?.public ?? 0,
         };
       });
     },

package/src/personal.ts

@@ -2,12 +2,14 @@
  * Authenticated-viewer memory access shared by REST and dashboard projections.
  *
  * Viewer identity may resolve to multiple platform actors. This module keeps
- * that federation behind one personal-memory collection.
+ * that federation behind one viewer-memory collection spanning personal and
+ * authorized public workspace scopes.
  */
 import { z } from "zod";
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
 import {
   createPersonalMemoryCollection,
+  type MemoryVisibility,
   type PersonalMemoryRecord,
 } from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
@@ -21,6 +23,7 @@ const cursorSchema = z
     origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
     version: z.literal(1),
+    visibility: z.enum(["private", "public"]).optional(),
   })
   .strict();
 
@@ -35,6 +38,7 @@ export interface ViewerMemoryPageInput {
   limit: number;
   origin?: "automatic" | "explicit";
   query?: string;
+  visibility?: MemoryVisibility;
 }
 
 export class InvalidMemoryCursorError extends Error {
@@ -45,6 +49,7 @@ export class InvalidMemoryCursorError extends Error {
 }
 
 export { PersonalMemoryNotFoundError } from "./personal-store";
+export type { MemoryVisibility, PersonalMemoryRecord } from "./personal-store";
 
 function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
   if (actor.platform === "slack") {
@@ -70,7 +75,7 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
 
 function decodeCursor(
   value: string | undefined,
-  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query">,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
 ) {
   if (!value) return undefined;
   try {
@@ -80,7 +85,8 @@ function decodeCursor(
     if (
       parsed.query !== input.query ||
       parsed.kind !== input.kind ||
-      parsed.origin !== input.origin
+      parsed.origin !== input.origin ||
+      parsed.visibility !== input.visibility
     ) {
       throw new InvalidMemoryCursorError();
     }
@@ -92,7 +98,7 @@ function decodeCursor(
 
 function encodeCursor(
   cursor: { createdAtMs: number; id: string },
-  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query">,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
 ): string {
   return Buffer.from(
     JSON.stringify({
@@ -100,13 +106,14 @@ function encodeCursor(
       ...(input.query ? { query: input.query } : {}),
       ...(input.kind ? { kind: input.kind } : {}),
       ...(input.origin ? { origin: input.origin } : {}),
+      ...(input.visibility ? { visibility: input.visibility } : {}),
       version: 1,
     }),
     "utf8",
   ).toString("base64url");
 }
 
-/** Build personal-memory operations authorized by a viewer's linked actors. */
+/** Build viewer memory operations authorized by a viewer's linked actors. */
 export function createViewerMemories(
   db: MemoryDb,
   actors: PluginUserPageActor[],
@@ -119,7 +126,7 @@ export function createViewerMemories(
     async archive(id: string): Promise<MemoryRecord> {
       return await collection.archive(id);
     },
-    async get(id: string): Promise<MemoryRecord> {
+    async get(id: string): Promise<PersonalMemoryRecord> {
       return await collection.get(id);
     },
     async list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage> {
@@ -128,6 +135,7 @@ export function createViewerMemories(
         ...(input.kind ? { kind: input.kind } : {}),
         ...(input.origin ? { origin: input.origin } : {}),
         ...(query ? { query } : {}),
+        ...(input.visibility ? { visibility: input.visibility } : {}),
       };
       const page = await collection.list({
         cursor: decodeCursor(input.cursor, filters),

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