@agentic-kit/run-log 0.5.0 → 0.7.0

package/esm/transcripts/entry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A harness's own session entry, as the log stores it.
+ *
+ * The log is deliberately not a re-encoding of a harness's transcript — an
+ * entry is kept byte-for-byte so the run stays resumable in the harness that
+ * wrote it. All the wrapper knows structurally is that an entry is an object
+ * with a `type`; what that type *means* is the reader's business, selected by
+ * the record's `transcriptFormat`.
+ */
+export interface TranscriptEntry {
+    /** The format's own entry discriminator, e.g. pi's `message`. */
+    type: string;
+    [key: string]: unknown;
+}
+export declare const isEntryRecord: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Narrow an untrusted value (a JSONB column, an HTTP body) to the structure
+ * every transcript shares. A format's own reader validates the rest.
+ */
+export declare function assertTranscriptEntry(value: unknown): TranscriptEntry;

package/esm/transcripts/entry.js

@@ -0,0 +1,23 @@
+/**
+ * A harness's own session entry, as the log stores it.
+ *
+ * The log is deliberately not a re-encoding of a harness's transcript — an
+ * entry is kept byte-for-byte so the run stays resumable in the harness that
+ * wrote it. All the wrapper knows structurally is that an entry is an object
+ * with a `type`; what that type *means* is the reader's business, selected by
+ * the record's `transcriptFormat`.
+ */
+export const isEntryRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Narrow an untrusted value (a JSONB column, an HTTP body) to the structure
+ * every transcript shares. A format's own reader validates the rest.
+ */
+export function assertTranscriptEntry(value) {
+    if (!isEntryRecord(value)) {
+        throw new TypeError(`transcript entry must be an object, received ${typeof value}`);
+    }
+    if (typeof value.type !== 'string' || value.type.length === 0) {
+        throw new TypeError('transcript entry must carry a non-empty string `type`');
+    }
+    return value;
+}

package/esm/transcripts/event.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The neutral vocabulary every projector reads.
+ *
+ * A projector used to know pi's message shapes, which made "render a run" and
+ * "read pi" the same capability. An event is what a transcript entry *means* —
+ * a model answered, a tool was called, a human was asked — so a format is
+ * understood in exactly one place (its `TranscriptReader`) and rendering,
+ * tracing and usage folding stop caring which harness ran.
+ *
+ * Kept close to what the projectors need rather than to any one harness: pi's
+ * `message`/`toolResult`/`custom` entries and DeepSeek Harness's
+ * `assistant/message`, `tool/call`, `tool/result` events both land here without
+ * either format's naming surviving the trip.
+ */
+import type { TranscriptEntry } from './entry';
+/** Tokens and cost as a transcript reports them — all fields optional. */
+export interface TranscriptUsage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    totalTokens?: number;
+    cost?: {
+        total?: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface TranscriptEventBase {
+    /** The entry's id in its own transcript, when the format gives entries ids. */
+    entryId?: string;
+    /** The entry's ISO timestamp, when it carries one. */
+    at?: string;
+}
+/** The transcript's opening entry: which session, and where it ran. */
+export interface SessionStartEvent extends TranscriptEventBase {
+    kind: 'session-start';
+    sessionId?: string;
+    cwd?: string;
+}
+export interface TextEvent extends TranscriptEventBase {
+    kind: 'text';
+    role: 'user' | 'assistant';
+    text: string;
+    model?: string;
+    provider?: string;
+}
+export interface ThinkingEvent extends TranscriptEventBase {
+    kind: 'thinking';
+    text: string;
+}
+/**
+ * A model finished answering. Separate from the text it produced because a
+ * trace and a usage total ask about the *call* — which model, what it cost, why
+ * it stopped — while a renderer asks about the content.
+ */
+export interface ModelResponseEvent extends TranscriptEventBase {
+    kind: 'model-response';
+    model?: string;
+    provider?: string;
+    /** The provider's response id — the join key to a metered inference row. */
+    responseId?: string;
+    stopReason?: string;
+    usage?: TranscriptUsage;
+    errorMessage?: string;
+}
+export interface ToolCallEvent extends TranscriptEventBase {
+    kind: 'tool-call';
+    toolCallId: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResultEvent extends TranscriptEventBase {
+    kind: 'tool-result';
+    toolCallId: string;
+    name: string;
+    output: string;
+    failed: boolean;
+    details?: unknown;
+    /** Nested model work the tool itself paid for. */
+    usage?: TranscriptUsage;
+}
+export interface BashEvent extends TranscriptEventBase {
+    kind: 'bash';
+    command: string;
+    output: string;
+    exitCode?: number;
+}
+/**
+ * A platform entry riding in the transcript — an approval request, a gate
+ * decision — discriminated by `customType` and interpreted by the entry-type
+ * registry rather than by a format's reader.
+ */
+export interface CustomEvent extends TranscriptEventBase {
+    kind: 'custom';
+    customType: string;
+    text: string;
+    /** Whether the entry is part of the conversation a human is shown. */
+    display: boolean;
+    details?: unknown;
+}
+export interface SummaryEvent extends TranscriptEventBase {
+    kind: 'summary';
+    reason: 'compaction' | 'branch';
+    summary: string;
+    usage?: TranscriptUsage;
+}
+/**
+ * An entry this reader does not understand. Carried rather than dropped: a log
+ * written by a newer harness still renders, minus the detail this version
+ * knows, and a projector never silently loses a row.
+ */
+export interface UnknownEvent extends TranscriptEventBase {
+    kind: 'unknown';
+    entryType: string;
+    entry: TranscriptEntry;
+}
+export type TranscriptEvent = SessionStartEvent | TextEvent | ThinkingEvent | ModelResponseEvent | ToolCallEvent | ToolResultEvent | BashEvent | CustomEvent | SummaryEvent | UnknownEvent;

package/esm/transcripts/event.js

@@ -0,0 +1,15 @@
+/**
+ * The neutral vocabulary every projector reads.
+ *
+ * A projector used to know pi's message shapes, which made "render a run" and
+ * "read pi" the same capability. An event is what a transcript entry *means* —
+ * a model answered, a tool was called, a human was asked — so a format is
+ * understood in exactly one place (its `TranscriptReader`) and rendering,
+ * tracing and usage folding stop caring which harness ran.
+ *
+ * Kept close to what the projectors need rather than to any one harness: pi's
+ * `message`/`toolResult`/`custom` entries and DeepSeek Harness's
+ * `assistant/message`, `tool/call`, `tool/result` events both land here without
+ * either format's naming surviving the trip.
+ */
+export {};

package/esm/transcripts/pi-entry.d.ts

@@ -16,6 +16,7 @@ export interface PiUsageCost {
     cacheRead?: number;
     cacheWrite?: number;
     total?: number;
+    [key: string]: unknown;
 }
 export interface PiUsage {
     input?: number;

package/esm/transcripts/pi-reader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * pi's transcript reader: pi session entries → neutral events.
+ *
+ * This is the only place in the package that knows pi's message shapes. It stays
+ * here rather than in `@agentic-kit/pi` on purpose — a reader must be
+ * browser-safe, because renderers project logs client-side, while the adapter
+ * package pulls pi's node SDK. The types it reads are structural (see
+ * `./pi-entry`), so nothing here imports pi either.
+ */
+import type { TranscriptEntry } from './entry';
+import type { TranscriptEvent } from './event';
+import type { TranscriptReader } from './reader';
+/** What a single pi entry means, in order. */
+export declare function piEntryToEvents(entry: TranscriptEntry): TranscriptEvent[];
+/** pi's session-file transcript (`@earendil-works/pi-coding-agent`). */
+export declare const piTranscriptReader: TranscriptReader;

package/esm/transcripts/pi-reader.js

@@ -0,0 +1,137 @@
+/**
+ * pi's transcript reader: pi session entries → neutral events.
+ *
+ * This is the only place in the package that knows pi's message shapes. It stays
+ * here rather than in `@agentic-kit/pi` on purpose — a reader must be
+ * browser-safe, because renderers project logs client-side, while the adapter
+ * package pulls pi's node SDK. The types it reads are structural (see
+ * `./pi-entry`), so nothing here imports pi either.
+ */
+import { PI_TRANSCRIPT_FORMAT, SUPPORTED_PI_TRANSCRIPT_VERSION } from './format';
+import { assertPiSessionEntry, contentText, isAssistantMessage, isPiBranchSummaryEntry, isPiCompactionEntry, isPiMessageEntry, isPiSessionHeader, isToolResultMessage, toolCalls } from './pi-entry';
+/** What a single pi entry means, in order. */
+export function piEntryToEvents(entry) {
+    const pi = entry;
+    const base = {
+        ...(typeof pi.id === 'string' ? { entryId: pi.id } : {}),
+        ...(typeof pi.timestamp === 'string' ? { at: pi.timestamp } : {})
+    };
+    if (isPiSessionHeader(pi)) {
+        return [
+            {
+                kind: 'session-start',
+                ...base,
+                ...(typeof pi.id === 'string' ? { sessionId: pi.id } : {}),
+                ...(typeof pi.cwd === 'string' ? { cwd: pi.cwd } : {})
+            }
+        ];
+    }
+    if (isPiCompactionEntry(pi)) {
+        return [
+            { kind: 'summary', reason: 'compaction', summary: pi.summary, ...(pi.usage ? { usage: pi.usage } : {}), ...base }
+        ];
+    }
+    if (isPiBranchSummaryEntry(pi)) {
+        return [
+            { kind: 'summary', reason: 'branch', summary: pi.summary, ...(pi.usage ? { usage: pi.usage } : {}), ...base }
+        ];
+    }
+    if (!isPiMessageEntry(pi)) {
+        return [{ kind: 'unknown', entryType: pi.type, entry, ...base }];
+    }
+    const message = pi.message;
+    if (message.role === 'user') {
+        return [{ kind: 'text', role: 'user', text: contentText(message.content), ...base }];
+    }
+    if (isAssistantMessage(message)) {
+        const events = [
+            {
+                kind: 'model-response',
+                ...(message.model ? { model: message.model } : {}),
+                ...(message.provider ? { provider: message.provider } : {}),
+                ...(typeof message.responseId === 'string' ? { responseId: message.responseId } : {}),
+                ...(message.stopReason ? { stopReason: message.stopReason } : {}),
+                ...(message.usage ? { usage: message.usage } : {}),
+                ...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
+                ...base
+            }
+        ];
+        for (const block of Array.isArray(message.content) ? message.content : []) {
+            if (block.type === 'text' && block.text.length > 0) {
+                events.push({
+                    kind: 'text',
+                    role: 'assistant',
+                    text: block.text,
+                    ...(message.model ? { model: message.model } : {}),
+                    ...(message.provider ? { provider: message.provider } : {}),
+                    ...base
+                });
+            }
+            else if (block.type === 'thinking') {
+                events.push({ kind: 'thinking', text: block.thinking, ...base });
+            }
+        }
+        for (const call of toolCalls(message)) {
+            events.push({
+                kind: 'tool-call',
+                toolCallId: call.id,
+                name: call.name,
+                arguments: call.arguments ?? {},
+                ...base
+            });
+        }
+        return events;
+    }
+    if (isToolResultMessage(message)) {
+        return [
+            {
+                kind: 'tool-result',
+                toolCallId: message.toolCallId,
+                name: message.toolName,
+                output: contentText(message.content),
+                failed: message.isError === true,
+                ...(message.details === undefined ? {} : { details: message.details }),
+                ...(message.usage ? { usage: message.usage } : {}),
+                ...base
+            }
+        ];
+    }
+    if (message.role === 'bashExecution') {
+        return [
+            {
+                kind: 'bash',
+                command: message.command,
+                output: message.output,
+                ...(typeof message.exitCode === 'number' ? { exitCode: message.exitCode } : {}),
+                ...base
+            }
+        ];
+    }
+    if (message.role === 'custom') {
+        return [
+            {
+                kind: 'custom',
+                customType: message.customType,
+                text: contentText(message.content),
+                display: message.display !== false,
+                ...(message.details === undefined ? {} : { details: message.details }),
+                ...base
+            }
+        ];
+    }
+    return [
+        {
+            kind: 'summary',
+            reason: message.role === 'branchSummary' ? 'branch' : 'compaction',
+            summary: message.summary ?? '',
+            ...base
+        }
+    ];
+}
+/** pi's session-file transcript (`@earendil-works/pi-coding-agent`). */
+export const piTranscriptReader = {
+    format: PI_TRANSCRIPT_FORMAT,
+    version: SUPPORTED_PI_TRANSCRIPT_VERSION,
+    assertEntry: assertPiSessionEntry,
+    toEvents: piEntryToEvents
+};

package/esm/transcripts/reader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The transcript reader registry: one place per format that knows how to read
+ * it, looked up by the format a record was written under.
+ *
+ * A reader is registered *by value*, like an entry type, so a second harness
+ * ships its reader with its adapter and neither this package nor a renderer is
+ * released to support it. A record names its format, so a run that changed
+ * harness mid-flight still projects as one ordered log.
+ */
+import { type TranscriptEntry } from './entry';
+import type { TranscriptEvent } from './event';
+import type { TranscriptFormat } from './format';
+export interface TranscriptReader {
+    format: TranscriptFormat;
+    /** The format version this reader projects without migration. */
+    version: number;
+    /** Narrow an untrusted entry of this format. Throws on anything unreadable. */
+    assertEntry: (value: unknown) => TranscriptEntry;
+    /**
+     * What the entry means, in order. One entry may mean several things — a pi
+     * assistant message is a model response plus its text plus its tool calls.
+     */
+    toEvents: (entry: TranscriptEntry) => TranscriptEvent[];
+}
+export declare class TranscriptReaderRegistry {
+    private readonly readers;
+    constructor(readers?: readonly TranscriptReader[]);
+    register(reader: TranscriptReader): this;
+    get(format: TranscriptFormat): TranscriptReader | undefined;
+    has(format: TranscriptFormat): boolean;
+    formats(): TranscriptFormat[];
+    /**
+     * The reader for a format, or a loud failure. A log whose format nothing can
+     * read must not render as an empty conversation — the missing piece is an
+     * unregistered adapter, and saying so is the only useful outcome.
+     */
+    require(format: TranscriptFormat): TranscriptReader;
+}
+/**
+ * A reader for a format whose entries the platform stores but cannot interpret.
+ *
+ * Every entry becomes an `unknown` event, which is enough to keep a log
+ * append-only, ordered and inspectable while its adapter is still being written.
+ */
+export declare function passthroughReader(format: TranscriptFormat, version?: number): TranscriptReader;

package/esm/transcripts/reader.js

@@ -0,0 +1,66 @@
+/**
+ * The transcript reader registry: one place per format that knows how to read
+ * it, looked up by the format a record was written under.
+ *
+ * A reader is registered *by value*, like an entry type, so a second harness
+ * ships its reader with its adapter and neither this package nor a renderer is
+ * released to support it. A record names its format, so a run that changed
+ * harness mid-flight still projects as one ordered log.
+ */
+import { assertTranscriptEntry } from './entry';
+export class TranscriptReaderRegistry {
+    readers = new Map();
+    constructor(readers = []) {
+        for (const reader of readers)
+            this.register(reader);
+    }
+    register(reader) {
+        this.readers.set(reader.format, reader);
+        return this;
+    }
+    get(format) {
+        return this.readers.get(format);
+    }
+    has(format) {
+        return this.readers.has(format);
+    }
+    formats() {
+        return Array.from(this.readers.keys()).sort();
+    }
+    /**
+     * The reader for a format, or a loud failure. A log whose format nothing can
+     * read must not render as an empty conversation — the missing piece is an
+     * unregistered adapter, and saying so is the only useful outcome.
+     */
+    require(format) {
+        const reader = this.readers.get(format);
+        if (!reader) {
+            const known = this.formats();
+            throw new Error(`no transcript reader registered for format "${format}"` +
+                (known.length === 0 ? '' : `; this registry reads ${known.join(', ')}`));
+        }
+        return reader;
+    }
+}
+/**
+ * A reader for a format whose entries the platform stores but cannot interpret.
+ *
+ * Every entry becomes an `unknown` event, which is enough to keep a log
+ * append-only, ordered and inspectable while its adapter is still being written.
+ */
+export function passthroughReader(format, version = 1) {
+    return {
+        format,
+        version,
+        assertEntry: assertTranscriptEntry,
+        toEvents: (entry) => [
+            {
+                kind: 'unknown',
+                entryType: entry.type,
+                entry,
+                ...(typeof entry.id === 'string' ? { entryId: entry.id } : {}),
+                ...(typeof entry.timestamp === 'string' ? { at: entry.timestamp } : {})
+            }
+        ]
+    };
+}

package/esm/transcripts/registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The registry the projectors use when a caller does not pass their own.
+ *
+ * pi is registered because it is the harness the platform ships; a host adding
+ * a second one either registers into its own registry or into this one at
+ * startup. Kept apart from `./reader` so the registry type does not depend on
+ * any format.
+ */
+import { TranscriptReaderRegistry } from './reader';
+/** Readers registered out of the box. */
+export declare const defaultTranscriptReaders: () => TranscriptReaderRegistry;
+/**
+ * The process-wide registry. Mutable on purpose: a host registers its adapter's
+ * reader once at startup and every projector call then reads that format.
+ */
+export declare const transcriptReaders: TranscriptReaderRegistry;

package/esm/transcripts/registry.js

@@ -0,0 +1,17 @@
+/**
+ * The registry the projectors use when a caller does not pass their own.
+ *
+ * pi is registered because it is the harness the platform ships; a host adding
+ * a second one either registers into its own registry or into this one at
+ * startup. Kept apart from `./reader` so the registry type does not depend on
+ * any format.
+ */
+import { piTranscriptReader } from './pi-reader';
+import { TranscriptReaderRegistry } from './reader';
+/** Readers registered out of the box. */
+export const defaultTranscriptReaders = () => new TranscriptReaderRegistry([piTranscriptReader]);
+/**
+ * The process-wide registry. Mutable on purpose: a host registers its adapter's
+ * reader once at startup and every projector call then reads that format.
+ */
+export const transcriptReaders = defaultTranscriptReaders();

package/file-store.d.ts

@@ -13,7 +13,7 @@
 import { type SessionProjectionOptions } from './projectors/session';
 import { type RunEventRecord } from './record';
 import { type AppendOptions, type RunLogCursor, type RunLogPage, type RunLogStore } from './store';
-import type { PiSessionEntry } from './transcripts/pi-entry';
+import type { TranscriptEntry } from './transcripts/entry';
 export interface FileRunLogStoreOptions {
     /** Absolute path of the log file. Parent directories are created. */
     path: string;
@@ -22,7 +22,7 @@ export declare class FileRunLogStore implements RunLogStore {
     private readonly path;
     constructor(options: FileRunLogStoreOptions);
     private load;
-    append(runId: string, entries: readonly PiSessionEntry[], options?: AppendOptions): Promise<RunEventRecord[]>;
+    append(runId: string, entries: readonly TranscriptEntry[], options?: AppendOptions): Promise<RunEventRecord[]>;
     read(runId: string, cursor?: RunLogCursor, limit?: number): Promise<RunLogPage>;
 }
 /**

package/index.d.ts

@@ -9,6 +9,7 @@
 export { constructiveEntryTypes, type EntryTypeDefinition, EntryTypeRegistry, type EntryVisibility } from './entry-types';
 export { follow, type FollowOptions, readAll } from './follow';
 export { type SessionEntrySource, SessionMirror, type SessionMirrorOptions } from './mirror';
+export { type EventGroup, type ProjectionOptions, type SequencedEvent, toEventGroups, toEvents } from './projectors/events';
 export { type BashPart, type Conversation, type ConversationPart, type CustomPart, projectParts, type SummaryPart, type TextPart, type ThinkingPart, type ToolPart, type ToolStatus, type UnknownPart } from './projectors/parts';
 export { parseSessionJsonl, projectSession, type SessionProjection, type SessionProjectionOptions } from './projectors/session';
 export { type ApprovalSpan, type ModelSpan, projectSpans, type Span, type SpanBase, type SpanKind, type SpanProjection, type SpanStatus, type SpanTiming, type ToolSpan } from './projectors/spans';
@@ -16,5 +17,10 @@ export { APPROVAL_REQUEST_TYPE, APPROVAL_RESOLUTION_TYPE, type ApprovalRequestIn
 export { modelKey, type ModelUsage, projectUsage, type RunUsage, type UsageTotals } from './projectors/usage';
 export { assertOrdered, assertRunEventRecord, idempotencyKey, RUN_LOG_WRAPPER_VERSION, type RunEventRecord, wrapEntry, type WrapEntryOptions } from './record';
 export { type AppendOptions, cursorAfter, MemoryRunLogStore, type RunLogAppendStore, type RunLogCursor, type RunLogPage, type RunLogReadStore, type RunLogStore, START } from './store';
+export { assertTranscriptEntry, type TranscriptEntry } from './transcripts/entry';
+export { type BashEvent, type CustomEvent, type ModelResponseEvent, type SessionStartEvent, type SummaryEvent, type TextEvent, type ThinkingEvent, type ToolCallEvent, type ToolResultEvent, type TranscriptEvent, type TranscriptEventBase, type TranscriptUsage, type UnknownEvent } from './transcripts/event';
 export { assertTranscriptFormat, PI_TRANSCRIPT_FORMAT, SUPPORTED_PI_TRANSCRIPT_VERSION, type TranscriptFormat } from './transcripts/format';
 export { assertPiSessionEntry, contentText, isAssistantMessage, isPiBranchSummaryEntry, isPiCompactionEntry, isPiMessageEntry, isPiSessionHeader, isToolResultMessage, type PiAssistantMessage, type PiBashExecutionMessage, type PiBranchSummaryEntry, type PiCompactionEntry, type PiContent, type PiCustomMessage, type PiEntryBase, type PiImageContent, type PiMessage, type PiMessageEntry, type PiOtherEntry, type PiSessionEntry, type PiSessionHeader, type PiSummaryMessage, type PiTextContent, type PiThinkingContent, type PiToolCallContent, type PiToolResultMessage, type PiUsage, type PiUsageCost, type PiUserMessage, toolCalls } from './transcripts/pi-entry';
+export { piEntryToEvents, piTranscriptReader } from './transcripts/pi-reader';
+export { passthroughReader, type TranscriptReader, TranscriptReaderRegistry } from './transcripts/reader';
+export { defaultTranscriptReaders, transcriptReaders } from './transcripts/registry';

package/index.js

@@ -8,7 +8,7 @@
  * `@agentic-kit/run-log/file-store`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolCalls = exports.isToolResultMessage = exports.isPiSessionHeader = exports.isPiMessageEntry = exports.isPiCompactionEntry = exports.isPiBranchSummaryEntry = exports.isAssistantMessage = exports.contentText = exports.assertPiSessionEntry = exports.SUPPORTED_PI_TRANSCRIPT_VERSION = exports.PI_TRANSCRIPT_FORMAT = exports.assertTranscriptFormat = exports.START = exports.MemoryRunLogStore = exports.cursorAfter = exports.wrapEntry = exports.RUN_LOG_WRAPPER_VERSION = exports.idempotencyKey = exports.assertRunEventRecord = exports.assertOrdered = exports.projectUsage = exports.modelKey = exports.projectToolState = exports.gateDecisionMessage = exports.GATE_DECISION_TYPE = exports.assertGateDecisionDetails = exports.assertApprovalResolutionDetails = exports.assertApprovalRequestDetails = exports.approvalResolutionMessage = exports.approvalRequestMessage = exports.APPROVAL_RESOLUTION_TYPE = exports.APPROVAL_REQUEST_TYPE = exports.projectSpans = exports.projectSession = exports.parseSessionJsonl = exports.projectParts = exports.SessionMirror = exports.readAll = exports.follow = exports.EntryTypeRegistry = exports.constructiveEntryTypes = void 0;
+exports.transcriptReaders = exports.defaultTranscriptReaders = exports.TranscriptReaderRegistry = exports.passthroughReader = exports.piTranscriptReader = exports.piEntryToEvents = exports.toolCalls = exports.isToolResultMessage = exports.isPiSessionHeader = exports.isPiMessageEntry = exports.isPiCompactionEntry = exports.isPiBranchSummaryEntry = exports.isAssistantMessage = exports.contentText = exports.assertPiSessionEntry = exports.SUPPORTED_PI_TRANSCRIPT_VERSION = exports.PI_TRANSCRIPT_FORMAT = exports.assertTranscriptFormat = exports.assertTranscriptEntry = exports.START = exports.MemoryRunLogStore = exports.cursorAfter = exports.wrapEntry = exports.RUN_LOG_WRAPPER_VERSION = exports.idempotencyKey = exports.assertRunEventRecord = exports.assertOrdered = exports.projectUsage = exports.modelKey = exports.projectToolState = exports.gateDecisionMessage = exports.GATE_DECISION_TYPE = exports.assertGateDecisionDetails = exports.assertApprovalResolutionDetails = exports.assertApprovalRequestDetails = exports.approvalResolutionMessage = exports.approvalRequestMessage = exports.APPROVAL_RESOLUTION_TYPE = exports.APPROVAL_REQUEST_TYPE = exports.projectSpans = exports.projectSession = exports.parseSessionJsonl = exports.projectParts = exports.toEvents = exports.toEventGroups = exports.SessionMirror = exports.readAll = exports.follow = exports.EntryTypeRegistry = exports.constructiveEntryTypes = void 0;
 var entry_types_1 = require("./entry-types");
 Object.defineProperty(exports, "constructiveEntryTypes", { enumerable: true, get: function () { return entry_types_1.constructiveEntryTypes; } });
 Object.defineProperty(exports, "EntryTypeRegistry", { enumerable: true, get: function () { return entry_types_1.EntryTypeRegistry; } });
@@ -17,6 +17,9 @@ Object.defineProperty(exports, "follow", { enumerable: true, get: function () {
 Object.defineProperty(exports, "readAll", { enumerable: true, get: function () { return follow_1.readAll; } });
 var mirror_1 = require("./mirror");
 Object.defineProperty(exports, "SessionMirror", { enumerable: true, get: function () { return mirror_1.SessionMirror; } });
+var events_1 = require("./projectors/events");
+Object.defineProperty(exports, "toEventGroups", { enumerable: true, get: function () { return events_1.toEventGroups; } });
+Object.defineProperty(exports, "toEvents", { enumerable: true, get: function () { return events_1.toEvents; } });
 var parts_1 = require("./projectors/parts");
 Object.defineProperty(exports, "projectParts", { enumerable: true, get: function () { return parts_1.projectParts; } });
 var session_1 = require("./projectors/session");
@@ -48,6 +51,8 @@ var store_1 = require("./store");
 Object.defineProperty(exports, "cursorAfter", { enumerable: true, get: function () { return store_1.cursorAfter; } });
 Object.defineProperty(exports, "MemoryRunLogStore", { enumerable: true, get: function () { return store_1.MemoryRunLogStore; } });
 Object.defineProperty(exports, "START", { enumerable: true, get: function () { return store_1.START; } });
+var entry_1 = require("./transcripts/entry");
+Object.defineProperty(exports, "assertTranscriptEntry", { enumerable: true, get: function () { return entry_1.assertTranscriptEntry; } });
 var format_1 = require("./transcripts/format");
 Object.defineProperty(exports, "assertTranscriptFormat", { enumerable: true, get: function () { return format_1.assertTranscriptFormat; } });
 Object.defineProperty(exports, "PI_TRANSCRIPT_FORMAT", { enumerable: true, get: function () { return format_1.PI_TRANSCRIPT_FORMAT; } });
@@ -62,3 +67,12 @@ Object.defineProperty(exports, "isPiMessageEntry", { enumerable: true, get: func
 Object.defineProperty(exports, "isPiSessionHeader", { enumerable: true, get: function () { return pi_entry_1.isPiSessionHeader; } });
 Object.defineProperty(exports, "isToolResultMessage", { enumerable: true, get: function () { return pi_entry_1.isToolResultMessage; } });
 Object.defineProperty(exports, "toolCalls", { enumerable: true, get: function () { return pi_entry_1.toolCalls; } });
+var pi_reader_1 = require("./transcripts/pi-reader");
+Object.defineProperty(exports, "piEntryToEvents", { enumerable: true, get: function () { return pi_reader_1.piEntryToEvents; } });
+Object.defineProperty(exports, "piTranscriptReader", { enumerable: true, get: function () { return pi_reader_1.piTranscriptReader; } });
+var reader_1 = require("./transcripts/reader");
+Object.defineProperty(exports, "passthroughReader", { enumerable: true, get: function () { return reader_1.passthroughReader; } });
+Object.defineProperty(exports, "TranscriptReaderRegistry", { enumerable: true, get: function () { return reader_1.TranscriptReaderRegistry; } });
+var registry_1 = require("./transcripts/registry");
+Object.defineProperty(exports, "defaultTranscriptReaders", { enumerable: true, get: function () { return registry_1.defaultTranscriptReaders; } });
+Object.defineProperty(exports, "transcriptReaders", { enumerable: true, get: function () { return registry_1.transcriptReaders; } });

package/mirror.d.ts

@@ -19,8 +19,8 @@
  */
 import type { RunEventRecord } from './record';
 import type { RunLogAppendStore } from './store';
-import type { TranscriptFormat } from './transcripts/format';
-import { type PiSessionEntry } from './transcripts/pi-entry';
+import { type TranscriptEntry } from './transcripts/entry';
+import { type TranscriptFormat } from './transcripts/format';
 /** The slice of a harness session manager the mirror needs. */
 export interface SessionEntrySource {
     getHeader(): unknown;
@@ -30,11 +30,11 @@ export interface SessionMirrorOptions {
     runId: string;
     store: RunLogAppendStore;
     /**
-     * Narrow each entry before it is appended. Defaults to the pi transcript
-     * reader, which is the only entry shape the record currently types; an adapter
-     * for another transcript supplies its own.
+     * Narrow each entry before it is appended. Defaults to the reader registered
+     * for `transcriptFormat`, so an adapter for another transcript gets its own
+     * validation by registering its reader.
      */
-    assertEntry?: (entry: unknown) => PiSessionEntry;
+    assertEntry?: (entry: unknown) => TranscriptEntry;
     /** Transcript format the entries are encoded in, e.g. `pi`. */
     transcriptFormat?: TranscriptFormat;
     /** Transcript format version the entries are produced under. */

package/mirror.js

@@ -20,7 +20,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionMirror = void 0;
-const pi_entry_1 = require("./transcripts/pi-entry");
+const format_1 = require("./transcripts/format");
+const registry_1 = require("./transcripts/registry");
 class SessionMirror {
     runId;
     store;
@@ -35,7 +36,9 @@ class SessionMirror {
     constructor(options) {
         this.runId = options.runId;
         this.store = options.store;
-        this.assertEntry = options.assertEntry ?? pi_entry_1.assertPiSessionEntry;
+        this.assertEntry =
+            options.assertEntry ??
+                registry_1.transcriptReaders.require(options.transcriptFormat ?? format_1.PI_TRANSCRIPT_FORMAT).assertEntry;
         this.transcriptFormat = options.transcriptFormat;
         this.transcriptVersion = options.transcriptVersion;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentic-kit/run-log",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "The append-only agent run log — pi session entries stored verbatim under a run/seq wrapper, with projections for transcript, usage, tool state and resumable sessions",
   "main": "index.js",
@@ -35,5 +35,5 @@
     "run-log",
     "constructive"
   ],
-  "gitHead": "b5b6b9f05276b7e9cbd3d1f4acd31dd315c353ea"
+  "gitHead": "baa84094b8541eb5000701b0060aa5b298032dc7"
 }