@sentry/junior-memory 0.191.0 → 0.193.0

package/dist/agent.d.ts

@@ -64,6 +64,14 @@ declare const createMemoryRequestSchema: z.ZodObject<{
             eventType: z.ZodString;
             identifier: z.ZodString;
             namespace: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"scheduled_task">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"event_task">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"plugin_dispatch">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent_invocation">;
         }, z.core.$strict>], "kind">, unknown>;
         userId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
@@ -151,6 +159,14 @@ declare const extractSessionRequestSchema: z.ZodObject<{
             eventType: z.ZodString;
             identifier: z.ZodString;
             namespace: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"scheduled_task">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"event_task">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"plugin_dispatch">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent_invocation">;
         }, z.core.$strict>], "kind">, unknown>;
         userId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;

package/dist/api.d.ts

@@ -63,21 +63,36 @@ export declare const memoryListResponseSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const memoryDashboardResponseSchema: z.ZodObject<{
     days: z.ZodArray<z.ZodObject<{
-        date: z.ZodISODate;
+        date: z.ZodString;
         personal: z.ZodNumber;
         public: z.ZodNumber;
     }, z.core.$strict>>;
     extractionDays: z.ZodArray<z.ZodObject<{
         costUsd: z.ZodNumber;
-        date: z.ZodISODate;
+        date: z.ZodString;
         events: z.ZodNumber;
     }, z.core.$strict>>;
+    extractionHours: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        costUsd: z.ZodNumber;
+        date: z.ZodString;
+        events: z.ZodNumber;
+    }, z.core.$strict>>>;
     generatedAt: z.ZodISODateTime;
+    hours: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        personal: z.ZodNumber;
+        public: z.ZodNumber;
+    }, z.core.$strict>>>;
     recallDays: z.ZodArray<z.ZodObject<{
         costUsd: z.ZodNumber;
-        date: z.ZodISODate;
+        date: z.ZodString;
         events: z.ZodNumber;
     }, z.core.$strict>>;
+    recallHours: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        costUsd: z.ZodNumber;
+        date: z.ZodString;
+        events: z.ZodNumber;
+    }, z.core.$strict>>>;
     stats: z.ZodObject<{
         active: z.ZodNumber;
         automatic: z.ZodNumber;

package/dist/index.js

@@ -368,10 +368,18 @@ var memoryRowSchema = z2.object({
   }
 });
 function storedMemorySource(source) {
-  if (source.kind === "resource_event") {
-    throw new Error("Resource event Source cannot own a Memory.");
+  switch (source.kind) {
+    case "slack":
+    case "local":
+    case "web":
+      return source.kind;
+    case "resource_event":
+    case "scheduled_task":
+    case "event_task":
+    case "plugin_dispatch":
+    case "agent_invocation":
+      throw new Error(`${source.kind} Source cannot own a Memory.`);
   }
-  return source.kind;
 }
 var memoryRecordSchema = z2.object({
   archivedAtMs: numberSchema.optional(),
@@ -1465,6 +1473,11 @@ function sourceLabel(source) {
       return `${source.kind}:${source.conversationId}`;
     case "resource_event":
       return `resource-event:${source.namespace}:${source.eventKey}`;
+    case "scheduled_task":
+    case "event_task":
+    case "plugin_dispatch":
+    case "agent_invocation":
+      return source.kind;
   }
 }
 function runtimeDescription(request) {
@@ -2035,6 +2048,39 @@ async function getMemoryTimeline(db, userId, days) {
     };
   });
 }
+async function getMemoryTimelineHours(db, userId, hours = 24) {
+  const end = /* @__PURE__ */ new Date();
+  end.setUTCMinutes(0, 0, 0);
+  const startMs = end.getTime() - (hours - 1) * 60 * 60 * 1e3;
+  const rows = await db.select({
+    date: sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24')`.as(
+      "date"
+    ),
+    private: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'private')`.mapWith(
+      Number
+    ),
+    public: sql3`count(*) filter (where ${juniorMemoryMemories.scope} = 'public')`.mapWith(
+      Number
+    )
+  }).from(juniorMemoryMemories).where(
+    and2(
+      visibleScopePredicate2(userId),
+      gt2(juniorMemoryMemories.createdAtMs, startMs - 1)
+    )
+  ).groupBy(
+    sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24')`
+  );
+  const byHour = new Map(rows.map((row) => [row.date, row]));
+  return Array.from({ length: hours }, (_, index2) => {
+    const date = new Date(startMs + index2 * 60 * 60 * 1e3).toISOString().slice(0, 13);
+    const row = byHour.get(date);
+    return {
+      date,
+      private: row?.private ?? 0,
+      public: row?.public ?? 0
+    };
+  });
+}
 
 // src/api.ts
 var memoryApiSchema = z5.object({
@@ -2052,21 +2098,25 @@ var memoryListResponseSchema = z5.object({
   memories: z5.array(memoryApiSchema),
   nextCursor: z5.string().min(1).optional()
 }).strict();
+var memoryBucketSchema = z5.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
 var memoryDashboardDaySchema = z5.object({
-  date: z5.iso.date(),
+  date: memoryBucketSchema,
   personal: z5.number().int().min(0),
   public: z5.number().int().min(0)
 }).strict();
 var memoryCostDaySchema = z5.object({
   costUsd: z5.number().finite().nonnegative(),
-  date: z5.iso.date(),
+  date: memoryBucketSchema,
   events: z5.number().int().min(0)
 }).strict();
 var memoryDashboardResponseSchema = z5.object({
   days: z5.array(memoryDashboardDaySchema).length(90),
   extractionDays: z5.array(memoryCostDaySchema).length(90),
+  extractionHours: z5.array(memoryCostDaySchema).length(24).optional(),
   generatedAt: z5.iso.datetime(),
+  hours: z5.array(memoryDashboardDaySchema).length(24).optional(),
   recallDays: z5.array(memoryCostDaySchema).length(90),
+  recallHours: z5.array(memoryCostDaySchema).length(24).optional(),
   stats: z5.object({
     active: z5.number().int().min(0),
     automatic: z5.number().int().min(0),
@@ -2134,16 +2184,31 @@ function createMemoryApi(options) {
       const userId = viewer.id;
       try {
         if (isDashboard && isRead) {
-          const [stats, days, extractionDays, recallDays] = await Promise.all([
+          const [
+            stats,
+            days,
+            hours,
+            extractionDays,
+            extractionHours,
+            recallDays,
+            recallHours
+          ] = await Promise.all([
             getMemoryStats(options.db, userId),
             getMemoryTimeline(options.db, userId, 90),
+            getMemoryTimelineHours(options.db, userId, 24),
             options.eventStats.costsByDay({
               days: 90,
               eventName: "memories_captured"
             }),
+            options.eventStats.costsByHour({
+              eventName: "memories_captured"
+            }),
             options.eventStats.costsByDay({
               days: 90,
               eventName: "memories_recalled"
+            }),
+            options.eventStats.costsByHour({
+              eventName: "memories_recalled"
             })
           ]);
           const { private: personal, ...dashboardStats } = stats;
@@ -2153,8 +2218,14 @@ function createMemoryApi(options) {
               personal: personal2
             })),
             extractionDays,
+            extractionHours,
             generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            hours: hours.map(({ private: personal2, ...day }) => ({
+              ...day,
+              personal: personal2
+            })),
             recallDays,
+            recallHours,
             stats: { ...dashboardStats, personal }
           });
           return request.method === "HEAD" ? new Response(null, {
@@ -2926,7 +2997,7 @@ async function getTaskExtraction(context, extract) {
 }
 async function processMemorySession(context) {
   const run = await context.run.load();
-  if (run.source.kind === "local" || run.source.kind === "resource_event") {
+  if (run.source.kind !== "slack" && run.source.kind !== "web") {
     return;
   }
   if (run.transcript.some(
@@ -3310,7 +3381,7 @@ async function buildMemoryOperationalReport(args) {
             public: day.public
           }
         })),
-        description: "Memories stored per day by scope",
+        description: "Memories stored by scope",
         id: "memories-created",
         series: [
           { key: "private", label: "Private" },