@superblocksteam/vite-plugin-file-sync 2.0.167-next.0 → 2.0.169-next.0

package/dist/ai-service/llm/context-v2/storage/event-types.d.ts

@@ -6,7 +6,9 @@
  * or compaction received). The event log replaces full-context JSON
  * blob storage with an incremental, corruption-tolerant format.
  */
-import type { SuperblocksMetadata } from "../types.js";
+import { z } from "zod";
+import type { ContextUsageSnapshot } from "@superblocksteam/library-shared/types";
+import type { AttachmentsRecord, SuperblocksMetadata } from "../types.js";
 /**
  * Discriminator for event log entries.
  *
@@ -16,7 +18,8 @@ import type { SuperblocksMetadata } from "../types.js";
  *   server-side compaction summary or the anchor marker written before a
  *   client-side phase-1 compaction window.
  */
-export type EventType = "prompt_sent" | "response_received" | "compaction_received";
+export declare const EventTypeSchema: z.ZodEnum<["prompt_sent", "response_received", "compaction_received", "context_state_updated"]>;
+export type EventType = z.infer<typeof EventTypeSchema>;
 /**
  * Content of the `compaction_received` marker written before a client-side
  * phase-1 compaction window. The marker is the replay anchor that
@@ -27,33 +30,158 @@ export declare const CLIENT_COMPACTION_MARKER = "Client-side compaction applied"
 /**
  * Message role aligned with AI SDK's `ModelMessage` role literals.
  */
-export type MessageRole = "user" | "assistant" | "tool" | "system";
+export declare const MessageRoleSchema: z.ZodEnum<["user", "assistant", "tool", "system"]>;
+export type MessageRole = z.infer<typeof MessageRoleSchema>;
 /**
- * A single entry in the JSONL event log.
+ * An event is one persisted JSONL entry. Message events represent conversation
+ * turns and replay into one `StoredMessage` each; `context_state_updated` is a
+ * state-only event and never appears in the replayed message list.
  *
  * Each entry captures a conversation turn with enough metadata to
  * reconstruct `StoredMessage[]` for the AI SDK. The `_superblocks`
  * field preserves round-trip metadata (token counts, summary flags)
  * through the storage layer.
+ *
+ * Prompt and compaction events may also carry an attachment snapshot. Prompt
+ * snapshots keep attachment state adjacent to the user turn that introduced it;
+ * compaction snapshots keep the catalog recoverable when message replay starts
+ * from the compaction anchor instead of the beginning of the log.
+ */
+export declare const MessageEventLogEntrySchema: z.ZodObject<{
+    type: z.ZodEnum<["prompt_sent", "response_received", "compaction_received"]>;
+    timestamp: z.ZodNumber;
+    role: z.ZodEnum<["user", "assistant", "tool", "system"]>;
+    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnknown, "many">]>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        cacheRead: number;
+    }, {
+        input: number;
+        output: number;
+        cacheRead: number;
+    }>>;
+    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _superblocks: z.ZodOptional<z.ZodType<SuperblocksMetadata, z.ZodTypeDef, SuperblocksMetadata>>;
+    attachments: z.ZodOptional<z.ZodType<AttachmentsRecord, z.ZodTypeDef, AttachmentsRecord>>;
+}, "strip", z.ZodTypeAny, {
+    type: "prompt_sent" | "response_received" | "compaction_received";
+    timestamp: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | unknown[];
+    _superblocks?: SuperblocksMetadata | undefined;
+    attachments?: AttachmentsRecord | undefined;
+    usage?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+    } | undefined;
+    providerMetadata?: Record<string, unknown> | undefined;
+}, {
+    type: "prompt_sent" | "response_received" | "compaction_received";
+    timestamp: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | unknown[];
+    _superblocks?: SuperblocksMetadata | undefined;
+    attachments?: AttachmentsRecord | undefined;
+    usage?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+    } | undefined;
+    providerMetadata?: Record<string, unknown> | undefined;
+}>;
+export type MessageEventLogEntry = z.infer<typeof MessageEventLogEntrySchema>;
+/**
+ * Non-message context state carried by the event log.
+ *
+ * Messages remain first-class event entries so compaction-window replay can
+ * keep using the append-only log. This state entry captures the remaining
+ * ContextRecordV2 fields that must survive after legacy main.json goes away.
  */
-export interface EventLogEntry {
-    /** Event discriminator. */
-    readonly type: EventType;
-    /** Unix epoch milliseconds when this event occurred. */
-    readonly timestamp: number;
-    /** Message role matching AI SDK `ModelMessage` role literals. */
-    readonly role: MessageRole;
-    /** Message content -- string, array of content parts, or other AI SDK content shapes. */
-    readonly content: unknown;
-    /** Token usage for this turn (typically set on response_received events). */
-    readonly usage?: {
-        readonly input: number;
-        readonly output: number;
-        readonly cacheRead: number;
-    };
-    /** Provider-specific metadata passed through from the AI SDK. */
-    readonly providerMetadata?: Record<string, unknown>;
-    /** Superblocks metadata preserved through storage round-trip (isSummary, tokenCount, etc.). */
-    readonly _superblocks?: SuperblocksMetadata;
-}
+export declare const ContextStateEventLogEntrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"context_state_updated">;
+    timestamp: z.ZodNumber;
+    attachments: z.ZodOptional<z.ZodType<AttachmentsRecord, z.ZodTypeDef, AttachmentsRecord>>;
+    lastContextUsage: z.ZodCatch<z.ZodOptional<z.ZodType<ContextUsageSnapshot, z.ZodTypeDef, ContextUsageSnapshot>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "context_state_updated";
+    timestamp: number;
+    attachments?: AttachmentsRecord | undefined;
+    lastContextUsage?: ContextUsageSnapshot | undefined;
+}, {
+    type: "context_state_updated";
+    timestamp: number;
+    attachments?: AttachmentsRecord | undefined;
+    lastContextUsage?: unknown;
+}>;
+export type ContextStateEventLogEntry = z.infer<typeof ContextStateEventLogEntrySchema>;
+export declare const EventLogEntrySchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodEnum<["prompt_sent", "response_received", "compaction_received"]>;
+    timestamp: z.ZodNumber;
+    role: z.ZodEnum<["user", "assistant", "tool", "system"]>;
+    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnknown, "many">]>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        cacheRead: number;
+    }, {
+        input: number;
+        output: number;
+        cacheRead: number;
+    }>>;
+    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _superblocks: z.ZodOptional<z.ZodType<SuperblocksMetadata, z.ZodTypeDef, SuperblocksMetadata>>;
+    attachments: z.ZodOptional<z.ZodType<AttachmentsRecord, z.ZodTypeDef, AttachmentsRecord>>;
+}, "strip", z.ZodTypeAny, {
+    type: "prompt_sent" | "response_received" | "compaction_received";
+    timestamp: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | unknown[];
+    _superblocks?: SuperblocksMetadata | undefined;
+    attachments?: AttachmentsRecord | undefined;
+    usage?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+    } | undefined;
+    providerMetadata?: Record<string, unknown> | undefined;
+}, {
+    type: "prompt_sent" | "response_received" | "compaction_received";
+    timestamp: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | unknown[];
+    _superblocks?: SuperblocksMetadata | undefined;
+    attachments?: AttachmentsRecord | undefined;
+    usage?: {
+        input: number;
+        output: number;
+        cacheRead: number;
+    } | undefined;
+    providerMetadata?: Record<string, unknown> | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"context_state_updated">;
+    timestamp: z.ZodNumber;
+    attachments: z.ZodOptional<z.ZodType<AttachmentsRecord, z.ZodTypeDef, AttachmentsRecord>>;
+    lastContextUsage: z.ZodCatch<z.ZodOptional<z.ZodType<ContextUsageSnapshot, z.ZodTypeDef, ContextUsageSnapshot>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "context_state_updated";
+    timestamp: number;
+    attachments?: AttachmentsRecord | undefined;
+    lastContextUsage?: ContextUsageSnapshot | undefined;
+}, {
+    type: "context_state_updated";
+    timestamp: number;
+    attachments?: AttachmentsRecord | undefined;
+    lastContextUsage?: unknown;
+}>]>;
+export type EventLogEntry = z.infer<typeof EventLogEntrySchema>;
 //# sourceMappingURL=event-types.d.ts.map

package/dist/ai-service/llm/context-v2/storage/event-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB,aAAa,GACb,mBAAmB,GACnB,qBAAqB,CAAC;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,mCAAmC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,iEAAiE;IACjE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpD,+FAA+F;IAC/F,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;CAC7C"}
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAyE1E;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,iGAK1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,mCAAmC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,iBAAiB,oDAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAerC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;EAO1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/ai-service/llm/context-v2/storage/event-types.js

@@ -6,6 +6,88 @@
  * or compaction received). The event log replaces full-context JSON
  * blob storage with an incremental, corruption-tolerant format.
  */
+import { z } from "zod";
+const storedAttachmentBaseSchema = z.object({
+    id: z.number(),
+    fileName: z.string().optional(),
+    label: z.string().optional(),
+    insight: z.string().optional(),
+    originalMessage: z.string().optional(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const storedAttachmentSchema = z.union([
+    storedAttachmentBaseSchema.extend({
+        type: z.literal("image"),
+        imageDataUrl: z.string(),
+    }),
+    storedAttachmentBaseSchema.extend({
+        type: z.literal("pdf"),
+        data: z.string(),
+        size: z.number().optional(),
+    }),
+    storedAttachmentBaseSchema.extend({
+        type: z.literal("archive"),
+        data: z.string(),
+        size: z.number().optional(),
+    }),
+    storedAttachmentBaseSchema.extend({
+        type: z.enum(["csv", "json", "yaml", "css", "txt"]),
+        content: z.string(),
+        mimeType: z.string(),
+        size: z.number().optional(),
+    }),
+    storedAttachmentBaseSchema.extend({
+        type: z.literal("uploaded"),
+        url: z.string(),
+        signedUrl: z.string().optional(),
+        mediaType: z.string(),
+        storageKey: z.string().optional(),
+        signedUrlExpiresAt: z.string().optional(),
+        scopeType: z.enum(["org", "app"]).optional(),
+        applicationId: z.string().optional(),
+    }),
+]);
+const attachmentsRecordSchema = z.object({
+    nextId: z.number(),
+    attachments: z.array(storedAttachmentSchema),
+});
+const contextUsageSnapshotSchema = z.object({
+    breakdown: z.object({
+        conversation: z.number(),
+        summarizedConversation: z.number(),
+        systemPrompt: z.number(),
+        tools: z.number(),
+    }),
+    compactionThreshold: z.number(),
+    contextLimit: z.number(),
+    contextUsed: z.number(),
+});
+const superblocksMetadataSchema = z.object({
+    tokenCount: z.number().optional(),
+    cumulativeInputTokens: z.number().optional(),
+    timestamp: z.number(),
+    isSummary: z.boolean().optional(),
+    protected: z.record(z.boolean()).optional(),
+    toolSummaries: z.record(z.string()).optional(),
+    summarized: z.boolean().optional(),
+    preCompactionInputTokenBaseline: z.boolean().optional(),
+});
+/**
+ * Discriminator for event log entries.
+ *
+ * - `prompt_sent`: A user prompt was sent to the LLM.
+ * - `response_received`: An assistant response was received from the LLM.
+ * - `compaction_received`: A compaction replaced earlier history — either a
+ *   server-side compaction summary or the anchor marker written before a
+ *   client-side phase-1 compaction window.
+ */
+export const EventTypeSchema = z.enum([
+    "prompt_sent",
+    "response_received",
+    "compaction_received",
+    "context_state_updated",
+]);
 /**
  * Content of the `compaction_received` marker written before a client-side
  * phase-1 compaction window. The marker is the replay anchor that
@@ -13,4 +95,63 @@
  * it because their first message carries `isSummary`.
  */
 export const CLIENT_COMPACTION_MARKER = "Client-side compaction applied";
+/**
+ * Message role aligned with AI SDK's `ModelMessage` role literals.
+ */
+export const MessageRoleSchema = z.enum([
+    "user",
+    "assistant",
+    "tool",
+    "system",
+]);
+/**
+ * An event is one persisted JSONL entry. Message events represent conversation
+ * turns and replay into one `StoredMessage` each; `context_state_updated` is a
+ * state-only event and never appears in the replayed message list.
+ *
+ * Each entry captures a conversation turn with enough metadata to
+ * reconstruct `StoredMessage[]` for the AI SDK. The `_superblocks`
+ * field preserves round-trip metadata (token counts, summary flags)
+ * through the storage layer.
+ *
+ * Prompt and compaction events may also carry an attachment snapshot. Prompt
+ * snapshots keep attachment state adjacent to the user turn that introduced it;
+ * compaction snapshots keep the catalog recoverable when message replay starts
+ * from the compaction anchor instead of the beginning of the log.
+ */
+export const MessageEventLogEntrySchema = z.object({
+    type: z.enum(["prompt_sent", "response_received", "compaction_received"]),
+    timestamp: z.number(),
+    role: MessageRoleSchema,
+    content: z.union([z.string(), z.array(z.unknown())]),
+    usage: z
+        .object({
+        input: z.number(),
+        output: z.number(),
+        cacheRead: z.number(),
+    })
+        .optional(),
+    providerMetadata: z.record(z.unknown()).optional(),
+    _superblocks: superblocksMetadataSchema.optional(),
+    attachments: attachmentsRecordSchema.optional(),
+});
+/**
+ * Non-message context state carried by the event log.
+ *
+ * Messages remain first-class event entries so compaction-window replay can
+ * keep using the append-only log. This state entry captures the remaining
+ * ContextRecordV2 fields that must survive after legacy main.json goes away.
+ */
+export const ContextStateEventLogEntrySchema = z.object({
+    type: z.literal("context_state_updated"),
+    timestamp: z.number(),
+    attachments: attachmentsRecordSchema.optional(),
+    // Display-only, so a malformed value degrades to absent instead of failing
+    // the whole entry, which would count as corruption and demote the log.
+    lastContextUsage: contextUsageSnapshotSchema.optional().catch(undefined),
+});
+export const EventLogEntrySchema = z.discriminatedUnion("type", [
+    MessageEventLogEntrySchema,
+    ContextStateEventLogEntrySchema,
+]);
 //# sourceMappingURL=event-types.js.map

package/dist/ai-service/llm/context-v2/storage/event-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"event-types.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,gCAAgC,CAAC"}
+{"version":3,"file":"event-types.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.d.ts

@@ -19,8 +19,9 @@
  * are skipped with a warning log, making the format tolerant to
  * partial writes or manual edits.
  */
-import type { ContextId, StoredMessage } from "../types.js";
-import type { EventStore } from "./event-store.js";
+import type { ContextUsageSnapshot } from "@superblocksteam/library-shared/types";
+import type { AttachmentsRecord, ContextId, StoredMessage } from "../types.js";
+import type { EventLogSnapshot, EventStore } from "./event-store.js";
 import type { EventLogEntry } from "./event-types.js";
 /**
  * Append-only JSONL event store backed by the local filesystem.
@@ -51,10 +52,19 @@ export declare class JsonlEventStore implements EventStore {
     appendEvent(id: ContextId, event: EventLogEntry, opts?: {
         shouldAbort?: () => boolean;
     }): Promise<void>;
+    appendAttachmentState(id: ContextId, attachments: AttachmentsRecord | undefined, opts?: {
+        shouldAbort?: () => boolean;
+    }, lastContextUsage?: ContextUsageSnapshot): Promise<void>;
     /**
      * Check whether any events exist for the given context.
      */
     hasEvents(id: ContextId): Promise<boolean>;
+    /**
+     * Atomically replace the event log. See {@link EventStore.replaceEvents}.
+     */
+    replaceEvents(id: ContextId, events: EventLogEntry[], opts?: {
+        shouldAbort?: () => boolean;
+    }): Promise<void>;
     /**
      * Remove the event log for a single context. Missing files are
      * treated as success so callers can use this as a fire-and-forget
@@ -91,6 +101,12 @@ export declare class JsonlEventStore implements EventStore {
      * consumers receive the AI SDK `ModelMessage` shape.
      */
     loadMessages(id: ContextId): Promise<StoredMessage[]>;
+    loadSnapshot(id: ContextId): Promise<EventLogSnapshot>;
+    private loadMessagesFromEvents;
+    loadAttachmentState(id: ContextId): Promise<AttachmentsRecord | undefined>;
+    private loadAttachmentStateFromEvents;
+    hasAttachmentState(id: ContextId): Promise<boolean>;
+    private hasAttachmentStateInEvents;
     /**
      * Map an EventLogEntry to a StoredMessage (AI SDK ModelMessage shape).
      *
@@ -102,6 +118,8 @@ export declare class JsonlEventStore implements EventStore {
      * against SDK version changes.
      */
     private toStoredMessage;
+    private loadEventEntries;
+    private isMessageEvent;
     private getEventsRoot;
     private getFilePath;
 }

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonl-event-store.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/jsonl-event-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,kBAAkB,CAAC;AAInE;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAIpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAkB;IAChE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAY;gBAEpB,OAAO,EAAE,MAAM;IAE5C;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,IAAI,CAAC;IAOhB;;OAEG;IACG,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAYhD;;;;OAIG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD;;;;;;;;;OASG;IACG,sBAAsB,CAC1B,EAAE,EAAE,SAAS,EACb,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAmElB;;;;;OAKG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAItC;;;;;;;;;;OAUG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAwE3D;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,WAAW;CAQpB"}
+{"version":3,"file":"jsonl-event-store.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/jsonl-event-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAaH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAQlF,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAEV,aAAa,EAGd,MAAM,kBAAkB,CAAC;AAK1B;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAIpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAkB;IAChE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAY;gBAEpB,OAAO,EAAE,MAAM;IAE5C;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,IAAI,CAAC;IAOV,qBAAqB,CACzB,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,iBAAiB,GAAG,SAAS,EAC1C,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,EACtC,gBAAgB,CAAC,EAAE,oBAAoB,GACtC,OAAO,CAAC,IAAI,CAAC;IAahB;;OAEG;IACG,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAIhD;;OAEG;IACG,aAAa,CACjB,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,IAAI,CAAC;IAsBhB;;;;OAIG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD;;;;;;;;;OASG;IACG,sBAAsB,CAC1B,EAAE,EAAE,SAAS,EACb,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAmElB;;;;;OAKG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAItC;;;;;;;;;;OAUG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAIrD,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoB5D,OAAO,CAAC,sBAAsB;IAoCxB,mBAAmB,CACvB,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAIzC,OAAO,CAAC,6BAA6B;IAe/B,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAIzD,OAAO,CAAC,0BAA0B;IAQlC;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;YAcT,gBAAgB;IA8C9B,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,WAAW;CAQpB"}

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.js

@@ -19,10 +19,12 @@
  * are skipped with a warning log, making the format tolerant to
  * partial writes or manual edits.
  */
+import { randomUUID } from "node:crypto";
 import { readFile, appendFile, mkdir, rename, rm, writeFile, } from "node:fs/promises";
 import * as path from "node:path";
 import { getPrefixedLogger } from "../../../../util/logger.js";
 import { encodeContextPathSegment, safeJoinUnderRoot, SHARED_CONTEXT_SEGMENT, } from "../../../context-archive-paths.js";
+import { EventLogEntrySchema } from "./event-types.js";
 const logger = getPrefixedLogger("[jsonl-event-store]");
 /**
  * Append-only JSONL event store backed by the local filesystem.
@@ -59,18 +61,39 @@ export class JsonlEventStore {
             return;
         await appendFile(filePath, JSON.stringify(event) + "\n");
     }
+    async appendAttachmentState(id, attachments, opts, lastContextUsage) {
+        await this.appendEvent(id, {
+            type: "context_state_updated",
+            timestamp: Date.now(),
+            ...(attachments !== undefined ? { attachments } : {}),
+            ...(lastContextUsage !== undefined ? { lastContextUsage } : {}),
+        }, opts);
+    }
     /**
      * Check whether any events exist for the given context.
      */
     async hasEvents(id) {
+        return (await this.loadSnapshot(id)).hasEvents;
+    }
+    /**
+     * Atomically replace the event log. See {@link EventStore.replaceEvents}.
+     */
+    async replaceEvents(id, events, opts) {
+        const filePath = this.getFilePath(id);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        // Unique per call, so a concurrent replace or truncate (which uses its own
+        // temp file) can never write into or rename away this one.
+        const tmpPath = `${filePath}.${randomUUID()}.tmp`;
         try {
-            const content = await readFile(this.getFilePath(id), "utf-8");
-            return content.trimEnd().length > 0;
+            await writeFile(tmpPath, events.map((event) => JSON.stringify(event) + "\n").join(""));
+            if (opts?.shouldAbort?.()) {
+                await rm(tmpPath, { force: true });
+                return;
+            }
+            await rename(tmpPath, filePath);
         }
         catch (err) {
-            if (err.code === "ENOENT") {
-                return false;
-            }
+            await rm(tmpPath, { force: true }).catch(() => { });
             throw err;
         }
     }
@@ -176,51 +199,29 @@ export class JsonlEventStore {
      * consumers receive the AI SDK `ModelMessage` shape.
      */
     async loadMessages(id) {
-        const filePath = this.getFilePath(id);
-        let raw;
-        try {
-            raw = await readFile(filePath, "utf-8");
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                return [];
-            }
-            throw err;
-        }
-        const lines = raw.split("\n").filter((line) => line.length > 0);
-        if (lines.length === 0) {
-            return [];
-        }
-        // Parse each line, skipping corrupted entries. A corrupted line could
-        // be the compaction anchor itself; if that happens the backward scan
-        // below will overshoot and return more history than intended, so we
-        // log loudly enough that the discrepancy is investigable.
-        //
-        // The raw line payload is intentionally NOT logged: even a partial
-        // JSONL fragment can contain user prompts or tool results, and those
-        // would otherwise leak into log sinks that don't share the event
-        // store's privacy boundary. Length is enough to debug truncation
-        // patterns without spilling content.
-        const contextLabel = `${id.appId}/${id.name}`;
-        const events = [];
-        let corruptedCount = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            try {
-                events.push(JSON.parse(line));
-            }
-            catch {
-                corruptedCount++;
-                logger.warn(`Skipping corrupted JSONL line ${i} for context '${contextLabel}' (length=${line.length})`);
-            }
-        }
-        if (corruptedCount > 0) {
-            logger.warn(`Encountered ${corruptedCount} corrupted line(s) in event log for context '${contextLabel}'; if any held a compaction anchor the loaded window may extend further back than expected.`);
-        }
+        return (await this.loadSnapshot(id)).messages;
+    }
+    async loadSnapshot(id) {
+        const { events, corruptedCount, contextLabel, hasContent } = await this.loadEventEntries(id);
+        return {
+            hasEvents: hasContent,
+            messages: this.loadMessagesFromEvents({
+                events,
+                corruptedCount,
+                contextLabel,
+            }),
+            hasAttachmentState: this.hasAttachmentStateInEvents(events),
+            attachments: this.loadAttachmentStateFromEvents(events),
+            lastContextUsage: events.findLast((event) => event.type === "context_state_updated")?.lastContextUsage,
+            corruptedCount,
+        };
+    }
+    loadMessagesFromEvents({ events, corruptedCount, contextLabel, }) {
+        const messageEvents = events.filter(this.isMessageEvent);
         // Backward scan: find the last compaction anchor
         let anchorIndex = -1;
-        for (let i = events.length - 1; i >= 0; i--) {
-            const event = events[i];
+        for (let i = messageEvents.length - 1; i >= 0; i--) {
+            const event = messageEvents[i];
             if (event.type === "compaction_received" ||
                 event._superblocks?.isSummary === true) {
                 anchorIndex = i;
@@ -230,9 +231,31 @@ export class JsonlEventStore {
         if (anchorIndex < 0 && corruptedCount > 0) {
             logger.error(`No compaction anchor found for context '${contextLabel}' but ${corruptedCount} corrupted line(s) were skipped; the loaded conversation window may be unbounded.`);
         }
-        const window = anchorIndex >= 0 ? events.slice(anchorIndex) : events;
+        const window = anchorIndex >= 0 ? messageEvents.slice(anchorIndex) : messageEvents;
         return window.map((event) => this.toStoredMessage(event));
     }
+    async loadAttachmentState(id) {
+        return (await this.loadSnapshot(id)).attachments;
+    }
+    loadAttachmentStateFromEvents(events) {
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            if (event.type === "context_state_updated") {
+                return event.attachments;
+            }
+            if (event.attachments !== undefined) {
+                return event.attachments;
+            }
+        }
+        return undefined;
+    }
+    async hasAttachmentState(id) {
+        return (await this.loadSnapshot(id)).hasAttachmentState;
+    }
+    hasAttachmentStateInEvents(events) {
+        return events.some((event) => event.type === "context_state_updated" ||
+            event.attachments !== undefined);
+    }
     /**
      * Map an EventLogEntry to a StoredMessage (AI SDK ModelMessage shape).
      *
@@ -256,6 +279,45 @@ export class JsonlEventStore {
             },
         };
     }
+    async loadEventEntries(id) {
+        const contextLabel = `${id.appId}/${id.name}`;
+        let raw;
+        try {
+            raw = await readFile(this.getFilePath(id), "utf-8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return {
+                    events: [],
+                    corruptedCount: 0,
+                    contextLabel,
+                    hasContent: false,
+                };
+            }
+            throw err;
+        }
+        const hasContent = raw.trimEnd().length > 0;
+        const lines = raw.split("\n").filter((line) => line.length > 0);
+        const events = [];
+        let corruptedCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            try {
+                events.push(EventLogEntrySchema.parse(JSON.parse(line)));
+            }
+            catch {
+                corruptedCount++;
+                logger.warn(`Skipping invalid JSONL line ${i} for context '${contextLabel}' (length=${line.length})`);
+            }
+        }
+        if (corruptedCount > 0) {
+            logger.warn(`Encountered ${corruptedCount} corrupted line(s) in event log for context '${contextLabel}'; if any held a compaction anchor the loaded window may extend further back than expected.`);
+        }
+        return { events, corruptedCount, contextLabel, hasContent };
+    }
+    isMessageEvent(event) {
+        return event.type !== "context_state_updated";
+    }
     getEventsRoot() {
         return path.join(this.rootDir, JsonlEventStore.SUPERBLOCKS_SYSTEM_DIR, JsonlEventStore.EVENTS_SUBDIR);
     }