@modelprofile.com/flexharness 3.6.0 → 3.8.0

package/dist_ts/interfaces.d.ts

@@ -129,6 +129,78 @@ export interface IFlexPromptOptions {
     system?: string;
     maxSteps?: number;
 }
+export interface IFlexSlashCommandInvocation {
+    input: string;
+    name: string;
+    rawArguments: string;
+    arguments: string[];
+}
+export interface IFlexSlashCommandNotCommandResult {
+    type: 'not-command';
+}
+export interface IFlexSlashCommandMalformedResult {
+    type: 'malformed';
+    reason: string;
+}
+export interface IFlexParsedSlashCommand extends IFlexSlashCommandInvocation {
+    type: 'parsed';
+}
+export type TFlexSlashCommandParseResult = IFlexSlashCommandNotCommandResult | IFlexSlashCommandMalformedResult | IFlexParsedSlashCommand;
+export type TFlexSlashCommandKind = 'builtin' | 'template' | 'handler';
+export type TFlexSlashCommandWorkspaceReversion = 'supported' | 'unsupported' | 'not-applicable';
+export interface IFlexSlashCommandDescriptor {
+    name: string;
+    description: string;
+    kind: TFlexSlashCommandKind;
+    hints: string[];
+    available: boolean;
+    unavailableReason?: string;
+    workspaceReversion: TFlexSlashCommandWorkspaceReversion;
+}
+export interface IFlexSlashCommandHandlerContext<TScope> {
+    readonly scopeId: string;
+    readonly scope: TScope;
+    readonly storageKey: string;
+    readonly sessionId: string;
+    readonly rawArguments: string;
+    readonly arguments: readonly string[];
+    readonly signal: AbortSignal;
+}
+export type TFlexSlashCommandHandler<TScope> = (context: IFlexSlashCommandHandlerContext<TScope>) => TJsonValue | void | Promise<TJsonValue | void>;
+export interface IFlexSlashCommandTemplateRegistration {
+    name: string;
+    description?: string;
+    template: string;
+    handler?: never;
+}
+export interface IFlexSlashCommandHandlerRegistration<TScope> {
+    name: string;
+    description?: string;
+    handler: TFlexSlashCommandHandler<TScope>;
+    template?: never;
+}
+export type TFlexSlashCommandRegistration<TScope> = IFlexSlashCommandTemplateRegistration | IFlexSlashCommandHandlerRegistration<TScope>;
+export interface IFlexSlashCommandExecutionOptions extends IFlexPromptOptions {
+    signal?: AbortSignal;
+}
+export interface IFlexSlashCommandUnknownResult extends IFlexSlashCommandInvocation {
+    type: 'unknown';
+}
+export interface IFlexSlashCommandOperationResult {
+    type: 'operation';
+    name: string;
+}
+export interface IFlexSlashCommandHandlerResult {
+    type: 'handler-result';
+    name: string;
+    result: TJsonValue;
+}
+export interface IFlexSlashCommandPromptAdmissionResult {
+    type: 'prompt-admission';
+    name: string;
+    admission: IFlexPromptAdmission;
+}
+export type TFlexSlashCommandExecutionResult = IFlexSlashCommandNotCommandResult | IFlexSlashCommandMalformedResult | IFlexSlashCommandUnknownResult | IFlexSlashCommandOperationResult | IFlexSlashCommandHandlerResult | IFlexSlashCommandPromptAdmissionResult;
 export type TFlexPromptQueueStatus = 'queued' | 'starting' | 'scheduled' | 'running' | 'completed' | 'failed' | 'cancelled';
 export interface IFlexPromptQueueEntry {
     queueId: string;
@@ -274,12 +346,90 @@ export interface IFlexTerminalProjection {
     finishReason?: string;
     steps?: number;
 }
-export interface IFlexProjectionSnapshot {
+export interface IFlexProjectionSnapshotV1 {
     schemaVersion: 1;
     revision: number;
     messages: IFlexMessage[];
     stagedTerminals: IFlexTerminalProjection[];
 }
+export type TFlexReversionSegmentStatus = 'capturing' | 'completed' | 'failed' | 'cancelled';
+export type TFlexReversionProtocolVersion = 1 | 2;
+export type TFlexReversionProvenance = 'transcript' | 'workspace';
+export type TFlexReversionDisposition = 'pending' | 'revertible' | 'no-change' | 'nonrevertible';
+export interface IFlexAffectedWorkspace {
+    readonly id: string;
+    readonly label: string;
+}
+interface IFlexReversionSegmentV2 {
+    runId: string;
+    userMessageId: string;
+    status: TFlexReversionSegmentStatus;
+    contextAvailable: boolean;
+    eventIds: string[];
+    workspaceCaptured: boolean;
+    captureId?: string;
+    workspaceReference?: TJsonValue;
+}
+export interface IFlexReversionSegment extends IFlexReversionSegmentV2 {
+    protocolVersion: TFlexReversionProtocolVersion;
+    provenance: TFlexReversionProvenance;
+    disposition?: TFlexReversionDisposition;
+    affectedWorkspaces?: IFlexAffectedWorkspace[];
+    reasonCode?: string;
+}
+interface IFlexPendingCaptureReversionV2 {
+    kind: 'capture';
+    runId: string;
+    captureId: string;
+    state: 'preparing' | 'prepared' | 'finalizing';
+}
+export interface IFlexPendingCaptureReversion extends IFlexPendingCaptureReversionV2 {
+    protocolVersion: TFlexReversionProtocolVersion;
+}
+export interface IFlexPendingApplyReversion {
+    kind: 'apply';
+    operationId: string;
+    direction: 'undo' | 'redo';
+    fromCursor: number;
+    toCursor: number;
+    segmentRunIds: string[];
+    appliedRunIds: string[];
+}
+type TFlexPendingReversionV2 = IFlexPendingCaptureReversionV2 | IFlexPendingApplyReversion;
+export type TFlexPendingReversion = IFlexPendingCaptureReversion | IFlexPendingApplyReversion;
+interface IFlexPendingReversionReleaseV2 {
+    runId: string;
+    captureId: string;
+    reference: TJsonValue;
+}
+export interface IFlexPendingReversionRelease extends IFlexPendingReversionReleaseV2 {
+    protocolVersion: TFlexReversionProtocolVersion;
+}
+export interface IFlexProjectionSnapshotV2 {
+    schemaVersion: 2;
+    revision: number;
+    messages: IFlexMessage[];
+    stagedTerminals: IFlexTerminalProjection[];
+    reversionSegments: IFlexReversionSegmentV2[];
+    revertCursor: number;
+    excludedRunIds: string[];
+    pendingReversion?: TFlexPendingReversionV2;
+    pendingReversionReleases: IFlexPendingReversionReleaseV2[];
+}
+export interface IFlexProjectionSnapshotV3 {
+    schemaVersion: 3;
+    revision: number;
+    messages: IFlexMessage[];
+    stagedTerminals: IFlexTerminalProjection[];
+    reversionSegments: IFlexReversionSegment[];
+    revertCursor: number;
+    excludedRunIds: string[];
+    pendingReversion?: TFlexPendingReversion;
+    pendingReversionReleases: IFlexPendingReversionRelease[];
+}
+export type IFlexProjectionSnapshot = IFlexProjectionSnapshotV1 | IFlexProjectionSnapshotV2 | IFlexProjectionSnapshotV3;
+export type TFlexProjectionSnapshot = IFlexProjectionSnapshot;
+export type IFlexProjectionSnapshotCurrent = IFlexProjectionSnapshotV3;
 export interface IFlexPermissionSnapshot {
     schemaVersion: 1;
     revision: number;
@@ -290,8 +440,8 @@ export interface IFlexScopeStore {
     save(storageKey: string, snapshot: IFlexScopeSnapshot, expectedRevision: number): Promise<void>;
 }
 export interface IFlexProjectionStore {
-    load(storageKey: string, sessionId: string): Promise<IFlexProjectionSnapshot | undefined>;
-    save(storageKey: string, sessionId: string, snapshot: IFlexProjectionSnapshot, expectedRevision: number): Promise<void>;
+    load(storageKey: string, sessionId: string): Promise<TFlexProjectionSnapshot | undefined>;
+    save(storageKey: string, sessionId: string, snapshot: IFlexProjectionSnapshotCurrent, expectedRevision: number): Promise<void>;
     deleteSession(storageKey: string, sessionId: string): Promise<void>;
 }
 export interface IFlexPermissionStore {
@@ -332,7 +482,114 @@ export interface IFlexPromptQueueLimits {
     maxPendingAdmissionBytes?: number;
     maxTerminalEntriesPerSession?: number;
 }
-export type TFlexExternalErrorSource = 'modelResolver' | 'toolProvider' | 'toolExecution' | 'toolCallback' | 'toolCleanup' | 'agentSession' | 'persistence';
+export interface IFlexReversionLimits {
+    maxCompletedTurns?: number;
+    maxSegments?: number;
+    maxExcludedRunIds?: number;
+    maxPendingReversionReleases?: number;
+}
+export declare const FLEX_REVERSION_DEFAULT_LIMITS: Readonly<{
+    maxCompletedTurns: 100;
+    maxSegments: 300;
+    maxExcludedRunIds: 1000;
+    maxPendingReversionReleases: 1000;
+}>;
+export declare const FLEX_REVERSION_MAXIMUM_LIMITS: Readonly<{
+    maxCompletedTurns: 1000;
+    maxSegments: 3000;
+    maxExcludedRunIds: 10000;
+    maxPendingReversionReleases: 10000;
+}>;
+export declare const FLEX_REVERSION_REFERENCE_MAX_BYTES: number;
+export declare const FLEX_REVERSION_MAX_AFFECTED_WORKSPACES = 64;
+export declare const FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES = 512;
+export declare const FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES = 2048;
+export declare const FLEX_REVERSION_REASON_CODE_MAX_BYTES = 128;
+export interface IFlexTurnReversionBaseContext<TScope> {
+    readonly scopeId: string;
+    readonly scope: TScope;
+    readonly storageKey: string;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly captureId: string;
+    readonly signal: AbortSignal;
+}
+export interface IFlexTurnReversionCaptureInspection {
+    status: 'missing' | 'prepared' | 'finalized' | 'unknown';
+    reference?: TJsonValue;
+}
+export interface IFlexTurnReversionApplyContext<TScope> extends IFlexTurnReversionBaseContext<TScope> {
+    readonly reference: TJsonValue;
+    readonly operationId: string;
+    readonly direction: 'undo' | 'redo';
+}
+export interface IFlexTurnReversionApplyInspection {
+    status: 'not-applied' | 'applied' | 'unknown';
+}
+export interface IFlexTurnReversionReleaseContext<TScope> extends IFlexTurnReversionBaseContext<TScope> {
+    readonly reference: TJsonValue;
+}
+export interface IFlexTurnReversionProvider<TScope> {
+    prepare(context: IFlexTurnReversionBaseContext<TScope>): Promise<void> | void;
+    inspectCapture(context: IFlexTurnReversionBaseContext<TScope>): Promise<IFlexTurnReversionCaptureInspection> | IFlexTurnReversionCaptureInspection;
+    finalize(context: IFlexTurnReversionBaseContext<TScope>): Promise<TJsonValue> | TJsonValue;
+    apply(context: IFlexTurnReversionApplyContext<TScope>): Promise<void> | void;
+    inspectApply(context: IFlexTurnReversionApplyContext<TScope>): Promise<IFlexTurnReversionApplyInspection> | IFlexTurnReversionApplyInspection;
+    release(context: IFlexTurnReversionReleaseContext<TScope>): Promise<void> | void;
+}
+export interface IFlexTurnReversionRevertibleOutcome {
+    readonly disposition: 'revertible';
+    readonly reference: TJsonValue;
+    readonly affectedWorkspaces: readonly IFlexAffectedWorkspace[];
+}
+export interface IFlexTurnReversionNoChangeOutcome {
+    readonly disposition: 'no-change';
+    readonly reference: TJsonValue;
+    readonly affectedWorkspaces?: readonly [];
+}
+export interface IFlexTurnReversionNonrevertibleOutcome {
+    readonly disposition: 'nonrevertible';
+    readonly reference: TJsonValue;
+    readonly reasonCode: string;
+    readonly affectedWorkspaces?: readonly IFlexAffectedWorkspace[];
+}
+export type TFlexTurnReversionFinalizedOutcome = IFlexTurnReversionRevertibleOutcome | IFlexTurnReversionNoChangeOutcome | IFlexTurnReversionNonrevertibleOutcome;
+export type TFlexTurnReversionCaptureInspectionV2 = {
+    readonly status: 'missing' | 'prepared' | 'unknown';
+} | {
+    readonly status: 'finalized';
+    readonly outcome: TFlexTurnReversionFinalizedOutcome;
+};
+export interface IFlexTurnReversionProviderV2<TScope> {
+    readonly protocolVersion: 2;
+    prepare(context: IFlexTurnReversionBaseContext<TScope>): Promise<void> | void;
+    inspectCapture(context: IFlexTurnReversionBaseContext<TScope>): Promise<TFlexTurnReversionCaptureInspectionV2> | TFlexTurnReversionCaptureInspectionV2;
+    finalize(context: IFlexTurnReversionBaseContext<TScope>): Promise<TFlexTurnReversionFinalizedOutcome> | TFlexTurnReversionFinalizedOutcome;
+    apply(context: IFlexTurnReversionApplyContext<TScope>): Promise<void> | void;
+    inspectApply(context: IFlexTurnReversionApplyContext<TScope>): Promise<IFlexTurnReversionApplyInspection> | IFlexTurnReversionApplyInspection;
+    release(context: IFlexTurnReversionReleaseContext<TScope>): Promise<void> | void;
+}
+export type TFlexReversionPolicy = 'transcript-optional' | 'workspace-required';
+export type TFlexSessionReversionGroupKind = 'candidate' | 'barrier' | 'no-change';
+export interface IFlexSessionReversionGroup {
+    readonly runId: string;
+    readonly kind: TFlexSessionReversionGroupKind;
+    readonly visibility: 'visible' | 'hidden';
+    readonly affectedWorkspaces: readonly IFlexAffectedWorkspace[];
+    readonly affectedWorkspacesTruncated: boolean;
+}
+export interface IFlexSessionReversionInfo {
+    readonly undoAvailable: boolean;
+    readonly redoAvailable: boolean;
+    readonly groups: readonly IFlexSessionReversionGroup[];
+}
+export interface IFlexUndoSessionResult {
+    revertedRunId: string;
+}
+export interface IFlexRedoSessionResult {
+    restoredRunId: string;
+}
+export type TFlexExternalErrorSource = 'modelResolver' | 'toolProvider' | 'toolExecution' | 'toolCallback' | 'toolCleanup' | 'agentSession' | 'persistence' | 'slashCommand' | 'turnReversion';
 export interface IFlexExternalErrorContext {
     source: TFlexExternalErrorSource;
     scopeId: string;
@@ -391,8 +648,12 @@ export interface IFlexHarnessOptions<TScope> {
     toolOutputLimits?: IFlexJsonLimits;
     callbackLimits?: IFlexCallbackLimits;
     promptQueueLimits?: IFlexPromptQueueLimits;
+    reversionLimits?: IFlexReversionLimits;
+    turnReversionProvider?: IFlexTurnReversionProvider<TScope> | IFlexTurnReversionProviderV2<TScope>;
+    reversionPolicy?: TFlexReversionPolicy;
     externalErrorProjector?: TFlexExternalErrorProjector;
     subagents?: IFlexSubagentDefinition[];
+    slashCommands?: readonly TFlexSlashCommandRegistration<TScope>[];
     maxSubagentDepth?: number;
     maxSubagentCallsPerRun?: number;
 }
@@ -494,10 +755,16 @@ export interface IFlexPromptQueueEvent extends IFlexEventBase {
     readonly runId?: string;
     readonly entry: IFlexPromptQueueEntry;
 }
+export interface IFlexSessionHistoryChangedEvent extends IFlexEventBase {
+    readonly type: 'session.history.changed';
+    readonly direction: 'undo' | 'redo' | 'branch';
+    readonly runId?: string;
+}
 export interface IFlexErrorInfo {
     name: string;
     message: string;
     code?: string;
 }
-export type TFlexHarnessEvent = IFlexSessionCreatedEvent | IFlexSessionUpdatedEvent | IFlexSessionDeletedEvent | IFlexRunStartedEvent | IFlexMessageChangedEvent | IFlexPartChangedEvent | IFlexPermissionRequestedEvent | IFlexPermissionResolvedEvent | IFlexRunFinishedEvent | IFlexPromptQueueEvent;
+export type TFlexHarnessEvent = IFlexSessionCreatedEvent | IFlexSessionUpdatedEvent | IFlexSessionDeletedEvent | IFlexRunStartedEvent | IFlexMessageChangedEvent | IFlexPartChangedEvent | IFlexPermissionRequestedEvent | IFlexPermissionResolvedEvent | IFlexRunFinishedEvent | IFlexPromptQueueEvent | IFlexSessionHistoryChangedEvent;
 export type TFlexHarnessEventListener = (event: TFlexHarnessEvent) => void;
+export {};

package/dist_ts/interfaces.js

@@ -1,2 +1,18 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+export const FLEX_REVERSION_DEFAULT_LIMITS = Object.freeze({
+    maxCompletedTurns: 100,
+    maxSegments: 300,
+    maxExcludedRunIds: 1000,
+    maxPendingReversionReleases: 1000,
+});
+export const FLEX_REVERSION_MAXIMUM_LIMITS = Object.freeze({
+    maxCompletedTurns: 1000,
+    maxSegments: 3000,
+    maxExcludedRunIds: 10_000,
+    maxPendingReversionReleases: 10_000,
+});
+export const FLEX_REVERSION_REFERENCE_MAX_BYTES = 256 * 1024;
+export const FLEX_REVERSION_MAX_AFFECTED_WORKSPACES = 64;
+export const FLEX_REVERSION_WORKSPACE_ID_MAX_BYTES = 512;
+export const FLEX_REVERSION_WORKSPACE_LABEL_MAX_BYTES = 2048;
+export const FLEX_REVERSION_REASON_CODE_MAX_BYTES = 128;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBeW9CQSxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ3pELGlCQUFpQixFQUFFLEdBQUc7SUFDdEIsV0FBVyxFQUFFLEdBQUc7SUFDaEIsaUJBQWlCLEVBQUUsSUFBSTtJQUN2QiwyQkFBMkIsRUFBRSxJQUFJO0NBQ2xDLENBQUMsQ0FBQztBQUVILE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDekQsaUJBQWlCLEVBQUUsSUFBSTtJQUN2QixXQUFXLEVBQUUsSUFBSTtJQUNqQixpQkFBaUIsRUFBRSxNQUFNO0lBQ3pCLDJCQUEyQixFQUFFLE1BQU07Q0FDcEMsQ0FBQyxDQUFDO0FBRUgsTUFBTSxDQUFDLE1BQU0sa0NBQWtDLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQztBQUM3RCxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsR0FBRyxFQUFFLENBQUM7QUFDekQsTUFBTSxDQUFDLE1BQU0scUNBQXFDLEdBQUcsR0FBRyxDQUFDO0FBQ3pELE1BQU0sQ0FBQyxNQUFNLHdDQUF3QyxHQUFHLElBQUksQ0FBQztBQUM3RCxNQUFNLENBQUMsTUFBTSxvQ0FBb0MsR0FBRyxHQUFHLENBQUMifQ==

package/dist_ts/plugins.d.ts

@@ -3,6 +3,6 @@ import * as crypto from 'node:crypto';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 export { AsyncLocalStorage, crypto, fs, path };
-import { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z } from '@push.rocks/smartagent';
-export { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
+import { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z } from '@push.rocks/smartagent';
+export { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
 export type { IAgentEventArchiveV2, IAgentContextCompactionOptions, IAgentEventSnapshotV2, IAgentEventStoreV2, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentRunResult, IAgentSession, IAgentSessionOptions, IAgentRuntimeEventPayload, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IToolExecutionContext, IToolExecutionIntentEvent, IToolJobSnapshot, IToolJobState, IToolJobStore, TAgentContextBuilder, TAgentContextCompactor, TAgentEvent, TAgentGenerationOutcome, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from '@push.rocks/smartagent';

package/dist_ts/plugins.js

@@ -5,6 +5,6 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 export { AsyncLocalStorage, crypto, fs, path };
 // @push.rocks scope
-import { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, } from '@push.rocks/smartagent';
-export { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFFbEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFL0Msb0JBQW9CO0FBQ3BCLE9BQU8sRUFDTCw0QkFBNEIsRUFDNUIsWUFBWSxFQUNaLGtCQUFrQixFQUNsQix5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLDhCQUE4QixFQUM5QiwwQkFBMEIsRUFDMUIsSUFBSSxFQUNKLDJCQUEyQixFQUMzQiw0QkFBNEIsRUFDNUIsQ0FBQyxHQUNGLE1BQU0sd0JBQXdCLENBQUM7QUFFaEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1QixZQUFZLEVBQ1osa0JBQWtCLEVBQ2xCLHlCQUF5QixFQUN6QixnQkFBZ0IsRUFDaEIsOEJBQThCLEVBQzlCLDBCQUEwQixFQUMxQixJQUFJLEVBQ0osMkJBQTJCLEVBQzNCLDRCQUE0QixFQUM1QixDQUFDLEdBQ0YsQ0FBQyJ9
+import { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, } from '@push.rocks/smartagent';
+export { AgentEventStoreConflictError, AgentSession, buildModelMessages, ToolJobStoreConflictError, createAgentEvent, filterModelVisibleAgentEvents, getAgentGenerationTransactions, modelMessagesToAgentEvents, tool, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, z, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFFbEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFL0Msb0JBQW9CO0FBQ3BCLE9BQU8sRUFDTCw0QkFBNEIsRUFDNUIsWUFBWSxFQUNaLGtCQUFrQixFQUNsQix5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLDZCQUE2QixFQUM3Qiw4QkFBOEIsRUFDOUIsMEJBQTBCLEVBQzFCLElBQUksRUFDSiwyQkFBMkIsRUFDM0IsNEJBQTRCLEVBQzVCLENBQUMsR0FDRixNQUFNLHdCQUF3QixDQUFDO0FBRWhDLE9BQU8sRUFDTCw0QkFBNEIsRUFDNUIsWUFBWSxFQUNaLGtCQUFrQixFQUNsQix5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLDZCQUE2QixFQUM3Qiw4QkFBOEIsRUFDOUIsMEJBQTBCLEVBQzFCLElBQUksRUFDSiwyQkFBMkIsRUFDM0IsNEJBQTRCLEVBQzVCLENBQUMsR0FDRixDQUFDIn0=

package/dist_ts/utils.json.d.ts

@@ -1,9 +1,12 @@
-import type { IFlexJsonLimits, IFlexPermissionSnapshot, IFlexProjectionSnapshot, IFlexScopeSnapshot, TFlexAgentModelMessage, TJsonValue } from './interfaces.js';
+import type { IFlexJsonLimits, IFlexPermissionSnapshot, IFlexProjectionSnapshotV1, IFlexProjectionSnapshotV2, IFlexProjectionSnapshotV3, IFlexScopeSnapshot, TFlexAgentModelMessage, TJsonValue } from './interfaces.js';
 export declare function resolveJsonLimits(limits?: IFlexJsonLimits): Required<IFlexJsonLimits>;
 export declare function normalizeJsonValue(value: unknown, limits?: IFlexJsonLimits): TJsonValue;
 export declare function assertJsonSerializable(value: unknown, path?: string): void;
 export declare function assertFlexScopeSnapshot(value: unknown): asserts value is IFlexScopeSnapshot;
-export declare function assertFlexProjectionSnapshot(value: unknown): asserts value is IFlexProjectionSnapshot;
+export declare function assertFlexProjectionSnapshotV1(value: unknown): asserts value is IFlexProjectionSnapshotV1;
+export declare function assertFlexProjectionSnapshotV2(value: unknown): asserts value is IFlexProjectionSnapshotV2;
+export declare function assertFlexProjectionSnapshotV3(value: unknown): asserts value is IFlexProjectionSnapshotV3;
+export declare function assertFlexProjectionSnapshot(value: unknown): asserts value is IFlexProjectionSnapshotV1 | IFlexProjectionSnapshotV2 | IFlexProjectionSnapshotV3;
 export declare function assertFlexPermissionSnapshot(value: unknown): asserts value is IFlexPermissionSnapshot;
 export declare function cloneSerializable<T>(value: T): T;
 export declare function deepFreeze<T>(value: T): T;