@sentry/junior-memory 0.124.1 → 0.125.0

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,

package/src/user-pages.ts

@@ -1,7 +1,10 @@
-/** 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";
 import { createViewerMemories } from "./personal";
-import type { PersonalMemoryRecord } from "./personal-store";
+import type {
+  MemoryVisibility,
+  PersonalMemoryRecord,
+} from "./personal-store";
 import type { MemoryDb } from "./store";
 
 function titleCase(value: string): string {
@@ -22,31 +25,33 @@ function originLabel(origin: PersonalMemoryRecord["origin"]): string {
   return "Other";
 }
 
+function visibilityLabel(visibility: MemoryVisibility): string {
+  return visibility === "public" ? "Public" : "Private";
+}
+
 function pageFilter(filter: string | undefined): {
-  kind?: "preference";
-  origin?: "automatic" | "explicit";
+  visibility?: MemoryVisibility;
 } {
-  if (filter === "preferences") return { kind: "preference" };
-  if (filter === "automatic") return { origin: "automatic" };
-  if (filter === "explicit") return { origin: "explicit" };
+  if (filter === "private") return { visibility: "private" };
+  if (filter === "public") return { visibility: "public" };
   return {};
 }
 
 function pageEmptyText(input: { filter?: string; query?: string }): string {
   if (input.query) return "No memories matched your search.";
-  if (input.filter === "preferences") return "No preferences yet.";
-  if (input.filter === "automatic") return "No learned memories yet.";
-  if (input.filter === "explicit") return "No saved memories yet.";
-  return "No personal memories yet.";
+  if (input.filter === "private") return "No private memories yet.";
+  if (input.filter === "public") return "No public memories yet.";
+  return "No memories yet.";
 }
 
-/** Create the interactive personal Memories dashboard page. */
+/** Create the interactive Memories dashboard page. */
 export function createMemoryUserPage(): PluginUserPageDefinition {
   return {
     id: "memories",
     label: "Memories",
     navigation: "primary",
-    description: "Personal facts and preferences Junior remembers about you.",
+    description:
+      "Personal and public memories Junior can use across conversations.",
     async read(ctx, input) {
       const memories = createViewerMemories(
         ctx.db as MemoryDb,
@@ -64,22 +69,28 @@ export function createMemoryUserPage(): PluginUserPageDefinition {
         ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
         searchPlaceholder: "Search memories",
         records: page.memories.map((memory) => ({
-          actions: [
-            {
-              confirmation: "Forget this memory?",
-              href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
-              label: "Forget",
-              method: "DELETE" as const,
-              tone: "danger" as const,
-            },
-          ],
+          actions:
+            memory.visibility === "private"
+              ? [
+                  {
+                    confirmation: "Forget this memory?",
+                    href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
+                    label: "Forget",
+                    method: "DELETE" as const,
+                    tone: "danger" as const,
+                  },
+                ]
+              : [],
           id: memory.id,
           title: memory.content,
           metadata: [
             { label: "Type", value: titleCase(memory.kind) },
             { label: "Learned", value: originLabel(memory.origin) },
             { label: "Source", value: titleCase(memory.sourcePlatform) },
-            { label: "Visibility", value: "Only you" },
+            {
+              label: "Visibility",
+              value: visibilityLabel(memory.visibility),
+            },
             { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
             { label: "Observed", value: rememberedDate(memory.observedAtMs) },
             {