@modelprofile.com/flexharness 2.0.0 → 3.0.0

package/dist_ts/utils.prompt.d.ts

@@ -1,6 +1,5 @@
-import type { TFlexAgentModelMessage, TFlexAgentPrompt, TFlexPrompt, TFlexPromptPart } from './interfaces.js';
+import type { TFlexAgentModelMessage, TFlexPrompt, TFlexPromptPart } from './interfaces.js';
 export interface INormalizedFlexPrompt {
-    agentPrompt: TFlexAgentPrompt;
     modelMessage: TFlexAgentModelMessage;
     parts: TFlexPromptPart[];
 }

package/dist_ts/utils.prompt.js

@@ -1,6 +1,5 @@
 import { FlexHarnessValidationError } from './errors.js';
-import { cloneSerializable } from './utils.json.js';
-import { assertJsonSerializable } from './utils.json.js';
+import { assertJsonSerializable, cloneSerializable, serializeAgentMessages, } from './utils.json.js';
 function isPlainObject(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
@@ -78,26 +77,6 @@ function rejectUnknownKeys(value, allowedKeys, path) {
         throw new FlexHarnessValidationError(`${path}.${unknownKey} is not a supported prompt field.`);
     }
 }
-function toAgentParts(parts) {
-    return parts.map((part) => {
-        if (part.type === 'text') {
-            return { type: 'text', text: part.text };
-        }
-        if (part.type === 'image') {
-            return {
-                type: 'image',
-                image: toAgentData(part.data),
-                ...(part.mediaType ? { mediaType: part.mediaType } : {}),
-            };
-        }
-        return {
-            type: 'file',
-            data: toAgentData(part.data),
-            mediaType: part.mediaType,
-            ...(part.name ? { filename: part.name } : {}),
-        };
-    });
-}
 function toStoredModelParts(parts) {
     return parts.map((part) => {
         if (part.type === 'text') {
@@ -132,7 +111,6 @@ export function normalizeFlexPrompt(prompt) {
             throw new FlexHarnessValidationError('prompt must not be empty.');
         }
         return {
-            agentPrompt: prompt,
             modelMessage: { role: 'user', content: prompt },
             parts: [{ type: 'text', text: prompt }],
         };
@@ -142,7 +120,6 @@ export function normalizeFlexPrompt(prompt) {
     }
     const parts = prompt.map(validatePart);
     return {
-        agentPrompt: toAgentParts(parts),
         modelMessage: {
             role: 'user',
             content: toStoredModelParts(parts),
@@ -151,7 +128,7 @@ export function normalizeFlexPrompt(prompt) {
     };
 }
 export function hydrateAgentMessages(messages) {
-    const hydrated = cloneSerializable(messages);
+    const hydrated = serializeAgentMessages(messages);
     for (const message of hydrated) {
         if (!Array.isArray(message.content)) {
             continue;
@@ -167,4 +144,4 @@ export function hydrateAgentMessages(messages) {
     }
     return hydrated;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMucHJvbXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdXRpbHMucHJvbXB0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQVN6RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQVF6RCxTQUFTLGFBQWEsQ0FBQyxLQUFjO0lBQ25DLElBQUksQ0FBQyxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNoRSxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCxNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9DLE9BQU8sU0FBUyxLQUFLLE1BQU0sQ0FBQyxTQUFTLElBQUksU0FBUyxLQUFLLElBQUksQ0FBQztBQUM5RCxDQUFDO0FBRUQsU0FBUyxxQkFBcUIsQ0FBQyxLQUFjLEVBQUUsSUFBWTtJQUN6RCxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3BELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUksOEJBQThCLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBQ0QsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRUQsU0FBUyxzQkFBc0IsQ0FBQyxLQUFjLEVBQUUsSUFBWTtJQUMxRCxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUN4QixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBQ0QsT0FBTyxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDNUMsQ0FBQztBQUVELFNBQVMsV0FBVyxDQUFDLElBQVk7SUFDL0IsSUFBSSxDQUFDO1FBQ0gsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUIsSUFBSSxHQUFHLENBQUMsUUFBUSxLQUFLLE9BQU8sSUFBSSxHQUFHLENBQUMsUUFBUSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzFELE9BQU8sR0FBRyxDQUFDO1FBQ2IsQ0FBQztJQUNILENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxzRUFBc0U7SUFDeEUsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVELFNBQVMsWUFBWSxDQUFDLEtBQWMsRUFBRSxLQUFhO0lBQ2pELE1BQU0sSUFBSSxHQUFHLFVBQVUsS0FBSyxHQUFHLENBQUM7SUFDaEMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQzFCLE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUksMEJBQTBCLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBQ0QsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQzFCLGlCQUFpQixDQUFDLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNqRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixJQUFJLEVBQUUscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLElBQUksT0FBTyxDQUFDO1NBQ3hELENBQUM7SUFDSixDQUFDO0lBQ0QsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQzNCLGlCQUFpQixDQUFDLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3RFLE1BQU0sSUFBSSxHQUF5QjtZQUNqQyxJQUFJLEVBQUUsT0FBTztZQUNiLElBQUksRUFBRSxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxPQUFPLENBQUM7U0FDeEQsQ0FBQztRQUNGLE1BQU0sU0FBUyxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsR0FBRyxJQUFJLFlBQVksQ0FBQyxDQUFDO1FBQy9FLE1BQU0sSUFBSSxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO1FBQ2hFLElBQUksU0FBUztZQUFFLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzFDLElBQUksSUFBSTtZQUFFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQzNCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FBQztRQUMxQixpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUN0RSxNQUFNLElBQUksR0FBd0I7WUFDaEMsSUFBSSxFQUFFLE1BQU07WUFDWixJQUFJLEVBQUUscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLElBQUksT0FBTyxDQUFDO1lBQ3ZELFNBQVMsRUFBRSxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLEdBQUcsSUFBSSxZQUFZLENBQUM7U0FDdkUsQ0FBQztRQUNGLE1BQU0sSUFBSSxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO1FBQ2hFLElBQUksSUFBSTtZQUFFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQzNCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUkscUNBQXFDLENBQUMsQ0FBQztBQUNyRixDQUFDO0FBRUQsU0FBUyxpQkFBaUIsQ0FDeEIsS0FBOEIsRUFDOUIsV0FBcUIsRUFDckIsSUFBWTtJQUVaLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNoRixJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQ2YsTUFBTSxJQUFJLDBCQUEwQixDQUFDLEdBQUcsSUFBSSxJQUFJLFVBQVUsbUNBQW1DLENBQUMsQ0FBQztJQUNqRyxDQUFDO0FBQ0gsQ0FBQztBQUVELFNBQVMsWUFBWSxDQUFDLEtBQXdCO0lBQzVDLE9BQU8sS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFO1FBQ3hCLElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FBQztZQUN6QixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQWUsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3BELENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxJQUFJLEtBQUssT0FBTyxFQUFFLENBQUM7WUFDMUIsT0FBTztnQkFDTCxJQUFJLEVBQUUsT0FBZ0I7Z0JBQ3RCLEtBQUssRUFBRSxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztnQkFDN0IsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO2FBQ3pELENBQUM7UUFDSixDQUFDO1FBQ0QsT0FBTztZQUNMLElBQUksRUFBRSxNQUFlO1lBQ3JCLElBQUksRUFBRSxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztZQUM1QixTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVM7WUFDekIsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1NBQzlDLENBQUM7SUFDSixDQUFDLENBQXFCLENBQUM7QUFDekIsQ0FBQztBQUVELFNBQVMsa0JBQWtCLENBQUMsS0FBd0I7SUFDbEQsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7UUFDeEIsSUFBSSxJQUFJLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQ3pCLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBZSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDcEQsQ0FBQztRQUNELElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUMxQixPQUFPO2dCQUNMLElBQUksRUFBRSxPQUFnQjtnQkFDdEIsS0FBSyxFQUFFLElBQUksQ0FBQyxJQUFJO2dCQUNoQixHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7YUFDekQsQ0FBQztRQUNKLENBQUM7UUFDRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQWU7WUFDckIsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsU0FBUyxFQUFFLElBQUksQ0FBQyxTQUFTO1lBQ3pCLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUM5QyxDQUFDO0lBQ0osQ0FBQyxDQUFxQixDQUFDO0FBQ3pCLENBQUM7QUFFRCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsTUFBbUI7SUFDckQsSUFBSSxDQUFDO1FBQ0gsc0JBQXNCLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxJQUFJLDBCQUEwQixDQUFDLDRDQUE0QyxFQUFFO1lBQ2pGLEtBQUssRUFBRSxLQUFLO1NBQ2IsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUNELElBQUksT0FBTyxNQUFNLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDL0IsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3hCLE1BQU0sSUFBSSwwQkFBMEIsQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO1FBQ3BFLENBQUM7UUFDRCxPQUFPO1lBQ0wsV0FBVyxFQUFFLE1BQU07WUFDbkIsWUFBWSxFQUFFLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFO1lBQy9DLEtBQUssRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7U0FDeEMsQ0FBQztJQUNKLENBQUM7SUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ2xELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyx3REFBd0QsQ0FBQyxDQUFDO0lBQ2pHLENBQUM7SUFDRCxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3ZDLE9BQU87UUFDTCxXQUFXLEVBQUUsWUFBWSxDQUFDLEtBQUssQ0FBQztRQUNoQyxZQUFZLEVBQUU7WUFDWixJQUFJLEVBQUUsTUFBTTtZQUNaLE9BQU8sRUFBRSxrQkFBa0IsQ0FBQyxLQUFLLENBQUM7U0FDbkM7UUFDRCxLQUFLLEVBQUUsaUJBQWlCLENBQUMsS0FBSyxDQUFDO0tBQ2hDLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLG9CQUFvQixDQUNsQyxRQUFrQztJQUVsQyxNQUFNLFFBQVEsR0FBRyxpQkFBaUIsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM3QyxLQUFLLE1BQU0sT0FBTyxJQUFJLFFBQVEsRUFBRSxDQUFDO1FBQy9CLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ3BDLFNBQVM7UUFDWCxDQUFDO1FBQ0QsS0FBSyxNQUFNLElBQUksSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbkMsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLE1BQU0sSUFBSSxJQUFJLENBQUMsSUFBSSxLQUFLLE9BQU8sSUFBSSxPQUFPLElBQUksQ0FBQyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7Z0JBQ3ZGLElBQUksQ0FBQyxLQUFLLEdBQUcsV0FBVyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUN2QyxDQUFDO2lCQUFNLElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxNQUFNLElBQUksT0FBTyxJQUFJLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUNqRSxJQUFJLENBQUMsSUFBSSxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDckMsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxRQUFRLENBQUM7QUFDbEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMucHJvbXB0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdXRpbHMucHJvbXB0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQVN6RCxPQUFPLEVBQ0wsc0JBQXNCLEVBQ3RCLGlCQUFpQixFQUNqQixzQkFBc0IsR0FDdkIsTUFBTSxpQkFBaUIsQ0FBQztBQU96QixTQUFTLGFBQWEsQ0FBQyxLQUFjO0lBQ25DLElBQUksQ0FBQyxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNoRSxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCxNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9DLE9BQU8sU0FBUyxLQUFLLE1BQU0sQ0FBQyxTQUFTLElBQUksU0FBUyxLQUFLLElBQUksQ0FBQztBQUM5RCxDQUFDO0FBRUQsU0FBUyxxQkFBcUIsQ0FBQyxLQUFjLEVBQUUsSUFBWTtJQUN6RCxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3BELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUksOEJBQThCLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBQ0QsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBRUQsU0FBUyxzQkFBc0IsQ0FBQyxLQUFjLEVBQUUsSUFBWTtJQUMxRCxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUN4QixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBQ0QsT0FBTyxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDNUMsQ0FBQztBQUVELFNBQVMsV0FBVyxDQUFDLElBQVk7SUFDL0IsSUFBSSxDQUFDO1FBQ0gsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDMUIsSUFBSSxHQUFHLENBQUMsUUFBUSxLQUFLLE9BQU8sSUFBSSxHQUFHLENBQUMsUUFBUSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzFELE9BQU8sR0FBRyxDQUFDO1FBQ2IsQ0FBQztJQUNILENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxzRUFBc0U7SUFDeEUsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVELFNBQVMsWUFBWSxDQUFDLEtBQWMsRUFBRSxLQUFhO0lBQ2pELE1BQU0sSUFBSSxHQUFHLFVBQVUsS0FBSyxHQUFHLENBQUM7SUFDaEMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQzFCLE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUksMEJBQTBCLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBQ0QsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQzFCLGlCQUFpQixDQUFDLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNqRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU07WUFDWixJQUFJLEVBQUUscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLElBQUksT0FBTyxDQUFDO1NBQ3hELENBQUM7SUFDSixDQUFDO0lBQ0QsSUFBSSxLQUFLLENBQUMsSUFBSSxLQUFLLE9BQU8sRUFBRSxDQUFDO1FBQzNCLGlCQUFpQixDQUFDLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLE1BQU0sQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3RFLE1BQU0sSUFBSSxHQUF5QjtZQUNqQyxJQUFJLEVBQUUsT0FBTztZQUNiLElBQUksRUFBRSxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxPQUFPLENBQUM7U0FDeEQsQ0FBQztRQUNGLE1BQU0sU0FBUyxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsR0FBRyxJQUFJLFlBQVksQ0FBQyxDQUFDO1FBQy9FLE1BQU0sSUFBSSxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO1FBQ2hFLElBQUksU0FBUztZQUFFLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO1FBQzFDLElBQUksSUFBSTtZQUFFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQzNCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FBQztRQUMxQixpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUN0RSxNQUFNLElBQUksR0FBd0I7WUFDaEMsSUFBSSxFQUFFLE1BQU07WUFDWixJQUFJLEVBQUUscUJBQXFCLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLElBQUksT0FBTyxDQUFDO1lBQ3ZELFNBQVMsRUFBRSxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLEdBQUcsSUFBSSxZQUFZLENBQUM7U0FDdkUsQ0FBQztRQUNGLE1BQU0sSUFBSSxHQUFHLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO1FBQ2hFLElBQUksSUFBSTtZQUFFLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQzNCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyxHQUFHLElBQUkscUNBQXFDLENBQUMsQ0FBQztBQUNyRixDQUFDO0FBRUQsU0FBUyxpQkFBaUIsQ0FDeEIsS0FBOEIsRUFDOUIsV0FBcUIsRUFDckIsSUFBWTtJQUVaLE1BQU0sVUFBVSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNoRixJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQ2YsTUFBTSxJQUFJLDBCQUEwQixDQUFDLEdBQUcsSUFBSSxJQUFJLFVBQVUsbUNBQW1DLENBQUMsQ0FBQztJQUNqRyxDQUFDO0FBQ0gsQ0FBQztBQUVELFNBQVMsa0JBQWtCLENBQUMsS0FBd0I7SUFDbEQsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7UUFDeEIsSUFBSSxJQUFJLENBQUMsSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQ3pCLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBZSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDcEQsQ0FBQztRQUNELElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUMxQixPQUFPO2dCQUNMLElBQUksRUFBRSxPQUFnQjtnQkFDdEIsS0FBSyxFQUFFLElBQUksQ0FBQyxJQUFJO2dCQUNoQixHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7YUFDekQsQ0FBQztRQUNKLENBQUM7UUFDRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQWU7WUFDckIsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJO1lBQ2YsU0FBUyxFQUFFLElBQUksQ0FBQyxTQUFTO1lBQ3pCLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUM5QyxDQUFDO0lBQ0osQ0FBQyxDQUFxQixDQUFDO0FBQ3pCLENBQUM7QUFFRCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsTUFBbUI7SUFDckQsSUFBSSxDQUFDO1FBQ0gsc0JBQXNCLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxJQUFJLDBCQUEwQixDQUFDLDRDQUE0QyxFQUFFO1lBQ2pGLEtBQUssRUFBRSxLQUFLO1NBQ2IsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUNELElBQUksT0FBTyxNQUFNLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDL0IsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3hCLE1BQU0sSUFBSSwwQkFBMEIsQ0FBQywyQkFBMkIsQ0FBQyxDQUFDO1FBQ3BFLENBQUM7UUFDRCxPQUFPO1lBQ0wsWUFBWSxFQUFFLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFO1lBQy9DLEtBQUssRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7U0FDeEMsQ0FBQztJQUNKLENBQUM7SUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ2xELE1BQU0sSUFBSSwwQkFBMEIsQ0FBQyx3REFBd0QsQ0FBQyxDQUFDO0lBQ2pHLENBQUM7SUFDRCxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3ZDLE9BQU87UUFDTCxZQUFZLEVBQUU7WUFDWixJQUFJLEVBQUUsTUFBTTtZQUNaLE9BQU8sRUFBRSxrQkFBa0IsQ0FBQyxLQUFLLENBQUM7U0FDbkM7UUFDRCxLQUFLLEVBQUUsaUJBQWlCLENBQUMsS0FBSyxDQUFDO0tBQ2hDLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLG9CQUFvQixDQUNsQyxRQUFrQztJQUVsQyxNQUFNLFFBQVEsR0FBRyxzQkFBc0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNsRCxLQUFLLE1BQU0sT0FBTyxJQUFJLFFBQVEsRUFBRSxDQUFDO1FBQy9CLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ3BDLFNBQVM7UUFDWCxDQUFDO1FBQ0QsS0FBSyxNQUFNLElBQUksSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbkMsSUFBSSxPQUFPLENBQUMsSUFBSSxLQUFLLE1BQU0sSUFBSSxJQUFJLENBQUMsSUFBSSxLQUFLLE9BQU8sSUFBSSxPQUFPLElBQUksQ0FBQyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7Z0JBQ3ZGLElBQUksQ0FBQyxLQUFLLEdBQUcsV0FBVyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUN2QyxDQUFDO2lCQUFNLElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxNQUFNLElBQUksT0FBTyxJQUFJLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUNqRSxJQUFJLENBQUMsSUFBSSxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDckMsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxRQUFRLENBQUM7QUFDbEIsQ0FBQyJ9

package/dist_ts_migration/index.d.ts

@@ -0,0 +1 @@
+export * from './v3_legacyflexharness.js';

package/dist_ts_migration/index.js

@@ -0,0 +1,2 @@
+export * from './v3_legacyflexharness.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQyJ9

package/dist_ts_migration/v3_legacyflexharness.d.ts

@@ -0,0 +1,17 @@
+import type { IFlexHarnessStores, IFlexMessage, IFlexSession, TJsonValue } from '../dist_ts/interfaces.js';
+export interface IFlexLegacyStoredSessionSnapshot {
+    session: IFlexSession;
+    messages: IFlexMessage[];
+    modelHistory: TJsonValue[];
+    rememberedPermissionKeys: string[];
+}
+export interface IFlexLegacyHarnessSnapshot {
+    schemaVersion: 1;
+    revision: number;
+    sessions: IFlexLegacyStoredSessionSnapshot[];
+}
+export interface IFlexLegacyHarnessStore {
+    load(storageKey: string): Promise<IFlexLegacyHarnessSnapshot | undefined>;
+}
+/** Migrates one stopped, exclusively owned 2.x storage namespace into the 3.x stores. */
+export declare function migrateLegacyFlexHarnessSnapshot(storageKey: string, legacySnapshot: IFlexLegacyHarnessSnapshot, stores: IFlexHarnessStores): Promise<void>;

package/dist_ts_migration/v3_legacyflexharness.js

@@ -0,0 +1,385 @@
+import * as plugins from '../dist_ts/plugins.js';
+import { FlexHarnessStoreFormatError, FlexHarnessValidationError } from '../dist_ts/errors.js';
+import { assertFlexPermissionSnapshot, assertFlexProjectionSnapshot, assertFlexScopeSnapshot, assertJsonSerializable, cloneSerializable, } from '../dist_ts/utils.json.js';
+function requireRecord(value, path) {
+    if (!value
+        || typeof value !== 'object'
+        || Array.isArray(value)
+        || (Object.getPrototypeOf(value) !== Object.prototype
+            && Object.getPrototypeOf(value) !== null)) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a plain object.`);
+    }
+    return value;
+}
+function requireOnlyKeys(value, allowedKeys, path) {
+    const unexpectedKey = Object.keys(value).find((key) => !allowedKeys.includes(key));
+    if (unexpectedKey) {
+        throw new FlexHarnessStoreFormatError(`${path}.${unexpectedKey} is not supported.`);
+    }
+}
+function requireNonNegativeInteger(value, path) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a non-negative integer.`);
+    }
+}
+function deterministicDigest(...values) {
+    return plugins.crypto.createHash('sha256').update(JSON.stringify(values)).digest('hex');
+}
+function deterministicEventId(storageKey, sessionId, ...coordinates) {
+    return `legacy_${deterministicDigest(storageKey, sessionId, ...coordinates)}`;
+}
+function deterministicTimestamp(value, path) {
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/i.test(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} must include an explicit timezone.`);
+    }
+    const timestamp = Date.parse(value);
+    if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
+        throw new FlexHarnessStoreFormatError(`${path} is invalid.`);
+    }
+    return timestamp;
+}
+function canonicalJson(value) {
+    const canonicalize = (current) => {
+        if (Array.isArray(current))
+            return current.map(canonicalize);
+        if (current && typeof current === 'object') {
+            return Object.fromEntries(Object.entries(current)
+                .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+                .map(([key, entry]) => [key, canonicalize(entry)]));
+        }
+        return current;
+    };
+    return JSON.stringify(canonicalize(value));
+}
+function withoutRevision(snapshot) {
+    const { revision: _revision, ...content } = snapshot;
+    return content;
+}
+function assertSameContent(actual, expected, destination) {
+    if (canonicalJson(actual) !== canonicalJson(expected)) {
+        throw new FlexHarnessStoreFormatError(`Legacy migration destination ${destination} already contains different content.`);
+    }
+}
+function groupLegacyRuns(messages, sessionId, path) {
+    const groups = new Map();
+    let priorTimestamp = -1;
+    for (const [index, message] of messages.entries()) {
+        const messagePath = `${path}[${index}]`;
+        if (message.sessionId !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`${messagePath}.sessionId does not match its session.`);
+        }
+        const timestamp = deterministicTimestamp(message.createdAt, `${messagePath}.createdAt`);
+        if (timestamp < priorTimestamp) {
+            throw new FlexHarnessStoreFormatError(`${path} must be in chronological order.`);
+        }
+        priorTimestamp = timestamp;
+        const group = groups.get(message.runId) ?? [];
+        group.push({ message, index, timestamp });
+        groups.set(message.runId, group);
+    }
+    const runs = [];
+    let expectedIndex = 0;
+    for (const [runId, group] of groups) {
+        if (group.length !== 2) {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" must contain exactly one user and one assistant message.`);
+        }
+        const [user, assistant] = group;
+        if (user.index !== expectedIndex || assistant.index !== expectedIndex + 1) {
+            throw new FlexHarnessStoreFormatError(`${path} contains ambiguous interleaved run groups.`);
+        }
+        expectedIndex += 2;
+        if (user.message.role !== 'user' || assistant.message.role !== 'assistant') {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" must contain a user message followed by an assistant message.`);
+        }
+        if (user.message.runId !== runId || assistant.message.runId !== runId) {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" has mismatched run IDs.`);
+        }
+        if (user.timestamp > assistant.timestamp) {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" is not chronological.`);
+        }
+        if (user.message.status === 'streaming' || assistant.message.status === 'streaming') {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" is not terminal.`);
+        }
+        if (user.message.status !== assistant.message.status) {
+            throw new FlexHarnessStoreFormatError(`${path} run "${runId}" has mismatched statuses.`);
+        }
+        runs.push({
+            runId,
+            status: user.message.status,
+            userMessage: user.message,
+            assistantMessage: assistant.message,
+        });
+    }
+    return runs;
+}
+function generationOutcome(status) {
+    if (status === 'completed')
+        return 'accepted';
+    if (status === 'failed')
+        return 'rejected';
+    return 'interrupted';
+}
+function createSessionAgentEvents(storageKey, stored, runs, path) {
+    const { sessionId } = stored.session;
+    const baseTimestamp = deterministicTimestamp(stored.session.createdAt, `${path}.session.createdAt`);
+    let sequence = 0;
+    const nextIdentity = () => {
+        sequence++;
+        const timestamp = baseTimestamp + sequence - 1;
+        if (!Number.isSafeInteger(timestamp)) {
+            throw new FlexHarnessStoreFormatError(`${path} contains too many events for its createdAt timestamp.`);
+        }
+        return { sequence, timestamp };
+    };
+    const converted = plugins.modelMessagesToAgentEvents(stored.modelHistory, {
+        identityFactory: (coordinates) => deterministicEventId(storageKey, sessionId, 'model-history', coordinates.messageIndex, coordinates.partIndex ?? null, coordinates.eventKind),
+    });
+    const events = converted.map((event) => ({
+        ...event,
+        ...nextIdentity(),
+    }));
+    for (const run of runs) {
+        const begun = plugins.createAgentEvent({
+            type: 'generation-begun',
+            id: deterministicEventId(storageKey, sessionId, 'run', run.runId, 'begun'),
+            ...nextIdentity(),
+            generationId: run.runId,
+            claimTokenDigest: deterministicDigest(storageKey, sessionId, run.runId, 'claim-token'),
+            ...(events.length > 0 ? { parentIds: [events[events.length - 1].id] } : {}),
+        });
+        const started = plugins.createAgentEvent({
+            type: 'generation-execution-started',
+            id: deterministicEventId(storageKey, sessionId, 'run', run.runId, 'execution-started'),
+            ...nextIdentity(),
+            generationId: run.runId,
+            parentIds: [begun.id],
+        });
+        const completed = plugins.createAgentEvent({
+            type: 'generation-execution-completed',
+            id: deterministicEventId(storageKey, sessionId, 'run', run.runId, 'execution-completed'),
+            ...nextIdentity(),
+            generationId: run.runId,
+            parentIds: [started.id],
+        });
+        const outcome = plugins.createAgentEvent({
+            type: 'generation-outcome',
+            id: deterministicEventId(storageKey, sessionId, 'run', run.runId, 'outcome'),
+            ...nextIdentity(),
+            generationId: run.runId,
+            outcome: generationOutcome(run.status),
+            parentIds: [completed.id],
+        });
+        events.push(begun, started, completed, outcome);
+    }
+    const jsonEvents = JSON.parse(JSON.stringify(events));
+    try {
+        plugins.validateAgentEventSnapshotV2({
+            schemaVersion: 2,
+            sessionId,
+            revision: 1,
+            updatedAt: baseTimestamp,
+            events: jsonEvents,
+        }, sessionId);
+    }
+    catch (error) {
+        throw new FlexHarnessStoreFormatError(`${path}.modelHistory cannot be converted to valid canonical Agent events: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const transactions = plugins.getAgentGenerationTransactions(jsonEvents);
+    if (transactions.size !== runs.length) {
+        throw new FlexHarnessStoreFormatError(`${path}.messages do not produce unambiguous transactions.`);
+    }
+    for (const run of runs) {
+        if (transactions.get(run.runId)?.state !== generationOutcome(run.status)) {
+            throw new FlexHarnessStoreFormatError(`${path}.messages run "${run.runId}" produces an invalid transaction lifecycle.`);
+        }
+    }
+    return jsonEvents;
+}
+function createMigrationPlan(storageKey, legacySnapshot) {
+    if (typeof storageKey !== 'string' || !storageKey.trim()) {
+        throw new FlexHarnessValidationError('storageKey must be a non-empty string.');
+    }
+    assertJsonSerializable(legacySnapshot, '$legacySnapshot');
+    const snapshot = requireRecord(legacySnapshot, '$legacySnapshot');
+    requireOnlyKeys(snapshot, ['schemaVersion', 'revision', 'sessions'], '$legacySnapshot');
+    if (snapshot.schemaVersion !== 1) {
+        throw new FlexHarnessStoreFormatError('Legacy snapshot schemaVersion must be 1.');
+    }
+    requireNonNegativeInteger(snapshot.revision, '$legacySnapshot.revision');
+    if (!Array.isArray(snapshot.sessions)) {
+        throw new FlexHarnessStoreFormatError('$legacySnapshot.sessions must be an array.');
+    }
+    const legacy = cloneSerializable(legacySnapshot);
+    const sessionIds = new Set();
+    const eventIds = new Set();
+    const sessions = legacy.sessions.map((stored, index) => {
+        const path = `$legacySnapshot.sessions[${index}]`;
+        const storedRecord = requireRecord(stored, path);
+        requireOnlyKeys(storedRecord, ['session', 'messages', 'modelHistory', 'rememberedPermissionKeys'], path);
+        const scopeSnapshot = {
+            schemaVersion: 1,
+            revision: 1,
+            sessions: [stored.session],
+            tombstones: [],
+        };
+        const projectionSnapshot = {
+            schemaVersion: 1,
+            revision: 1,
+            messages: stored.messages,
+            stagedTerminals: [],
+        };
+        const permissionSnapshot = {
+            schemaVersion: 1,
+            revision: 1,
+            rememberedPermissionKeys: stored.rememberedPermissionKeys,
+        };
+        assertFlexScopeSnapshot(scopeSnapshot);
+        assertFlexProjectionSnapshot(projectionSnapshot);
+        assertFlexPermissionSnapshot(permissionSnapshot);
+        const { sessionId } = stored.session;
+        if (sessionIds.has(sessionId)) {
+            throw new FlexHarnessStoreFormatError(`$legacySnapshot contains duplicate session "${sessionId}".`);
+        }
+        sessionIds.add(sessionId);
+        const runs = groupLegacyRuns(stored.messages, sessionId, `${path}.messages`);
+        const agentEvents = createSessionAgentEvents(storageKey, stored, runs, path);
+        for (const event of agentEvents) {
+            if (eventIds.has(event.id)) {
+                throw new FlexHarnessStoreFormatError(`$legacySnapshot produces duplicate Agent event ID "${event.id}".`);
+            }
+            eventIds.add(event.id);
+        }
+        return {
+            sessionId,
+            projectionSnapshot: cloneSerializable(projectionSnapshot),
+            permissionSnapshot: cloneSerializable(permissionSnapshot),
+            agentEvents,
+        };
+    });
+    const scopeSnapshot = {
+        schemaVersion: 1,
+        revision: 1,
+        sessions: legacy.sessions.map((stored) => cloneSerializable(stored.session)),
+        tombstones: [],
+    };
+    assertFlexScopeSnapshot(scopeSnapshot);
+    return { scopeSnapshot, sessions };
+}
+function assertCompatibleJobSnapshot(snapshot, sessionId) {
+    if (!snapshot)
+        return;
+    if (snapshot.schemaVersion !== 1
+        || !Number.isSafeInteger(snapshot.revision)
+        || snapshot.revision < 0
+        || !Number.isSafeInteger(snapshot.updatedAt)
+        || snapshot.updatedAt < 0
+        || !Array.isArray(snapshot.jobs)
+        || snapshot.jobs.length > 0) {
+        throw new FlexHarnessStoreFormatError(`Legacy migration destination jobs for session "${sessionId}" is not an empty job snapshot.`);
+    }
+}
+async function inspectDestinations(storageKey, plan, stores, ownership) {
+    const scope = await stores.scopes.load(storageKey);
+    const sessions = [];
+    for (const session of plan.sessions) {
+        const [projection, permission] = await Promise.all([
+            stores.projections.load(storageKey, session.sessionId),
+            stores.permissions.load(storageKey, session.sessionId),
+        ]);
+        const eventStore = await stores.agentEvents.getStore(storageKey, session.sessionId);
+        ownership.agentEvents.add(session.sessionId);
+        const jobStore = await stores.jobs.getStore(storageKey, session.sessionId);
+        ownership.jobs.add(session.sessionId);
+        const [eventSnapshot, jobSnapshot] = await Promise.all([
+            eventStore.load(session.sessionId),
+            jobStore.load(),
+        ]);
+        sessions.push({
+            plan: session,
+            projection,
+            permission,
+            eventStore,
+            eventSnapshot: eventSnapshot,
+            jobSnapshot,
+        });
+    }
+    if (scope) {
+        assertSameContent(withoutRevision(scope), withoutRevision(plan.scopeSnapshot), 'scope snapshot');
+    }
+    for (const session of sessions) {
+        if (session.projection) {
+            assertSameContent(withoutRevision(session.projection), withoutRevision(session.plan.projectionSnapshot), `projection snapshot for session "${session.plan.sessionId}"`);
+        }
+        if (session.permission) {
+            assertSameContent(withoutRevision(session.permission), withoutRevision(session.plan.permissionSnapshot), `permission snapshot for session "${session.plan.sessionId}"`);
+        }
+        if (session.eventSnapshot) {
+            assertSameContent({
+                schemaVersion: session.eventSnapshot.schemaVersion,
+                sessionId: session.eventSnapshot.sessionId,
+                events: session.eventSnapshot.events,
+            }, {
+                schemaVersion: 2,
+                sessionId: session.plan.sessionId,
+                events: session.plan.agentEvents,
+            }, `Agent events for session "${session.plan.sessionId}"`);
+        }
+        assertCompatibleJobSnapshot(session.jobSnapshot, session.plan.sessionId);
+    }
+    return { scope, sessions };
+}
+async function releaseMigrationProviders(storageKey, stores, ownership) {
+    const releases = [];
+    if (stores.agentEvents.releaseSession) {
+        for (const sessionId of ownership.agentEvents) {
+            releases.push(Promise.resolve().then(() => stores.agentEvents.releaseSession(storageKey, sessionId)));
+        }
+    }
+    if (stores.jobs.releaseSession) {
+        for (const sessionId of ownership.jobs) {
+            releases.push(Promise.resolve().then(() => stores.jobs.releaseSession(storageKey, sessionId)));
+        }
+    }
+    const results = await Promise.allSettled(releases);
+    return results
+        .filter((result) => result.status === 'rejected')
+        .map((result) => result.reason);
+}
+/** Migrates one stopped, exclusively owned 2.x storage namespace into the 3.x stores. */
+export async function migrateLegacyFlexHarnessSnapshot(storageKey, legacySnapshot, stores) {
+    const plan = createMigrationPlan(storageKey, legacySnapshot);
+    const ownership = {
+        agentEvents: new Set(),
+        jobs: new Set(),
+    };
+    let operationError;
+    try {
+        const destinations = await inspectDestinations(storageKey, plan, stores, ownership);
+        for (const destination of destinations.sessions) {
+            const session = destination.plan;
+            if (!destination.projection) {
+                await stores.projections.save(storageKey, session.sessionId, session.projectionSnapshot, 0);
+            }
+            if (!destination.permission) {
+                await stores.permissions.save(storageKey, session.sessionId, session.permissionSnapshot, 0);
+            }
+            if (!destination.eventSnapshot) {
+                await destination.eventStore.save(session.sessionId, session.agentEvents, 0);
+            }
+        }
+        if (!destinations.scope) {
+            await stores.scopes.save(storageKey, plan.scopeSnapshot, 0);
+        }
+    }
+    catch (error) {
+        operationError = error;
+    }
+    const errors = await releaseMigrationProviders(storageKey, stores, ownership);
+    if (operationError !== undefined)
+        errors.unshift(operationError);
+    if (errors.length === 1)
+        throw errors[0];
+    if (errors.length > 1)
+        throw new AggregateError(errors, 'Legacy FlexHarness migration failed.');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v3_legacyflexharness.js","sourceRoot":"","sources":["../../ts_migration/v3_legacyflexharness.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,31 +1,45 @@
 {
   "name": "@modelprofile.com/flexharness",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "private": false,
   "description": "Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist_ts/index.d.ts",
+      "import": "./dist_ts/index.js"
+    },
+    "./migration": {
+      "types": "./dist_ts_migration/index.d.ts",
+      "import": "./dist_ts_migration/index.js"
+    }
+  },
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "engines": {
     "node": ">=24"
   },
   "dependencies": {
-    "@push.rocks/smartagent": "^4.0.0",
+    "@push.rocks/smartagent": "^4.6.0",
     "@types/json-schema": "7.0.15"
   },
   "devDependencies": {
     "@git.zone/tsbuild": "4.4.2",
     "@git.zone/tsrun": "2.0.6",
     "@git.zone/tstest": "4.0.0",
-    "@types/node": "26.1.2"
+    "@types/node": "26.2.0",
+    "ai": "6.0.237"
   },
   "files": [
     "ts/**/*",
+    "ts_migration/**/*",
     "dist_ts/**/*",
+    "dist_ts_migration/**/*",
     ".smartconfig.json",
     "readme.md",
+    "changelog.md",
     "license.md"
   ],
   "scripts": {