@modelprofile.com/flexharness 1.0.0

package/dist_ts/utils.json.d.ts

@@ -0,0 +1,8 @@
+import type { IFlexHarnessSnapshot, IFlexJsonLimits, 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 assertFlexHarnessSnapshot(value: unknown): asserts value is IFlexHarnessSnapshot;
+export declare function cloneSerializable<T>(value: T): T;
+export declare function deepFreeze<T>(value: T): T;
+export declare function serializeAgentMessages(messages: TFlexAgentModelMessage[]): TFlexAgentModelMessage[];

package/dist_ts/utils.json.js

@@ -0,0 +1,540 @@
+import { FlexHarnessStoreFormatError, FlexHarnessValidationError } from './errors.js';
+const DEFAULT_MAX_DEPTH = 12;
+const DEFAULT_MAX_BYTES = 256 * 1024;
+const MIN_MAX_BYTES = 128;
+function isPlainObject(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function makeDescription(type, values = {}) {
+    return {
+        $flexType: type,
+        ...values,
+    };
+}
+function binaryBytes(value) {
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return undefined;
+}
+export function resolveJsonLimits(limits = {}) {
+    const maxDepth = limits.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const maxBytes = limits.maxBytes ?? DEFAULT_MAX_BYTES;
+    if (!Number.isSafeInteger(maxDepth) || maxDepth < 1) {
+        throw new FlexHarnessValidationError('toolOutputLimits.maxDepth must be a positive integer.');
+    }
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < MIN_MAX_BYTES) {
+        throw new FlexHarnessValidationError(`toolOutputLimits.maxBytes must be an integer of at least ${MIN_MAX_BYTES}.`);
+    }
+    return { maxDepth, maxBytes };
+}
+export function normalizeJsonValue(value, limits = {}) {
+    const resolvedLimits = resolveJsonLimits(limits);
+    const seen = new WeakMap();
+    const measure = (entry) => ({
+        value: entry,
+        bytes: Buffer.byteLength(JSON.stringify(entry)),
+    });
+    const shortString = (entry, maximumCharacters = 160) => entry.length > maximumCharacters ? `${entry.slice(0, maximumCharacters)}...` : entry;
+    const description = (type, values, allowance) => {
+        const detailed = measure(makeDescription(type, values));
+        if (detailed.bytes <= allowance)
+            return detailed;
+        const compact = measure(makeDescription('truncated', { reason: 'bytes' }));
+        if (compact.bytes <= allowance)
+            return compact;
+        return measure('[truncated]');
+    };
+    const nextPath = (path, suffix) => `${path.slice(0, 80)}${suffix.slice(0, 48)}`;
+    const visit = (current, depth, path, allowance) => {
+        if (current === null || typeof current === 'boolean')
+            return measure(current);
+        if (typeof current === 'string') {
+            const rawBytes = Buffer.byteLength(current);
+            if (rawBytes + 2 > allowance) {
+                return description('truncated', { reason: 'bytes', byteLength: rawBytes }, allowance);
+            }
+            const encoded = measure(current);
+            return encoded.bytes <= allowance
+                ? encoded
+                : description('truncated', { reason: 'bytes', byteLength: rawBytes }, allowance);
+        }
+        if (typeof current === 'number') {
+            return Number.isFinite(current)
+                ? measure(current)
+                : description('number', { value: String(current) }, allowance);
+        }
+        if (typeof current === 'undefined') {
+            return description('undefined', {}, allowance);
+        }
+        if (typeof current === 'bigint') {
+            const valueString = current.toString();
+            return description('bigint', Buffer.byteLength(valueString) < allowance / 2
+                ? { value: valueString }
+                : { description: '[bigint exceeds byte budget]' }, allowance);
+        }
+        if (typeof current === 'function') {
+            return description('function', {
+                description: current.name
+                    ? `[Function ${shortString(current.name)}]`
+                    : '[Function anonymous]',
+            }, allowance);
+        }
+        if (typeof current === 'symbol') {
+            return description('symbol', { description: shortString(String(current)) }, allowance);
+        }
+        if (depth >= resolvedLimits.maxDepth) {
+            return description('truncated', { reason: 'depth', path: shortString(path) }, allowance);
+        }
+        const objectValue = current;
+        const firstPath = seen.get(objectValue);
+        if (firstPath) {
+            return description('circular', { path: firstPath }, allowance);
+        }
+        if (current instanceof Date) {
+            return description('date', { value: Number.isNaN(current.getTime()) ? 'Invalid Date' : current.toISOString() }, allowance);
+        }
+        if (current instanceof URL) {
+            const urlString = current.toString();
+            return description('url', { value: shortString(urlString), truncated: urlString.length > 160 }, allowance);
+        }
+        const binary = binaryBytes(objectValue);
+        if (binary) {
+            const maximumSourceBytes = Math.max(0, Math.floor((allowance - 120) * 0.7));
+            const included = binary.subarray(0, maximumSourceBytes);
+            return description('binary', {
+                encoding: 'base64',
+                data: Buffer.from(included).toString('base64'),
+                byteLength: binary.byteLength,
+                truncated: included.byteLength < binary.byteLength,
+            }, allowance);
+        }
+        if (current instanceof Error) {
+            return description('error', { name: shortString(current.name), message: shortString(current.message) }, allowance);
+        }
+        if (current instanceof RegExp) {
+            return description('regexp', { value: shortString(current.toString()) }, allowance);
+        }
+        seen.set(objectValue, path);
+        if (Array.isArray(current)) {
+            const normalized = [];
+            let encodedBytes = 2;
+            for (let index = 0; index < current.length; index++) {
+                const separatorBytes = normalized.length > 0 ? 1 : 0;
+                const remainingItems = current.length - index;
+                const truncation = description('truncated', { reason: 'bytes', omittedItems: remainingItems }, allowance);
+                const truncationReserve = index < current.length - 1
+                    ? 1 + truncation.bytes
+                    : 0;
+                const childAllowance = allowance - encodedBytes - separatorBytes - truncationReserve;
+                if (childAllowance < 48) {
+                    if (encodedBytes + separatorBytes + truncation.bytes <= allowance) {
+                        normalized.push(truncation.value);
+                        encodedBytes += separatorBytes + truncation.bytes;
+                    }
+                    return { value: normalized, bytes: encodedBytes };
+                }
+                let entry;
+                try {
+                    entry = current[index];
+                }
+                catch (error) {
+                    entry = makeDescription('unreadable', {
+                        description: shortString(error instanceof Error ? error.message : String(error)),
+                    });
+                }
+                const child = visit(entry, depth + 1, nextPath(path, `[${index}]`), childAllowance);
+                normalized.push(child.value);
+                encodedBytes += separatorBytes + child.bytes;
+            }
+            return { value: normalized, bytes: encodedBytes };
+        }
+        if (!isPlainObject(objectValue)) {
+            const constructorName = objectValue.constructor?.name ?? 'Object';
+            return description('object', { description: `[${shortString(constructorName)}]` }, allowance);
+        }
+        const normalized = {};
+        let encodedBytes = 2;
+        let visitedProperties = 0;
+        let truncated = false;
+        let truncationKey = '$flexTruncated';
+        while (Object.prototype.hasOwnProperty.call(current, truncationKey)) {
+            truncationKey += '_';
+        }
+        for (const key in current) {
+            if (!Object.prototype.hasOwnProperty.call(current, key))
+                continue;
+            const separatorBytes = visitedProperties > 0 ? 1 : 0;
+            const truncation = description('truncated', { reason: 'bytes', visitedProperties }, allowance);
+            const truncationPropertyBytes = (visitedProperties > 0 ? 1 : 0) +
+                Buffer.byteLength(JSON.stringify(truncationKey)) +
+                1 +
+                truncation.bytes;
+            const rawKeyBytes = Buffer.byteLength(key);
+            if (rawKeyBytes + 2 >= allowance - encodedBytes - truncationPropertyBytes) {
+                truncated = true;
+                break;
+            }
+            const encodedKeyBytes = Buffer.byteLength(JSON.stringify(key));
+            const childAllowance = allowance -
+                encodedBytes -
+                separatorBytes -
+                encodedKeyBytes -
+                1 -
+                truncationPropertyBytes;
+            if (childAllowance < 48) {
+                truncated = true;
+                break;
+            }
+            let entry;
+            try {
+                entry = current[key];
+            }
+            catch (error) {
+                entry = makeDescription('unreadable', {
+                    description: shortString(error instanceof Error ? error.message : String(error)),
+                });
+            }
+            const child = visit(entry, depth + 1, nextPath(path, `.${key}`), childAllowance);
+            normalized[key] = child.value;
+            encodedBytes += separatorBytes + encodedKeyBytes + 1 + child.bytes;
+            visitedProperties++;
+        }
+        if (truncated) {
+            const truncation = description('truncated', { reason: 'bytes', visitedProperties }, allowance);
+            const separatorBytes = visitedProperties > 0 ? 1 : 0;
+            normalized[truncationKey] = truncation.value;
+            encodedBytes +=
+                separatorBytes +
+                    Buffer.byteLength(JSON.stringify(truncationKey)) +
+                    1 +
+                    truncation.bytes;
+        }
+        return { value: normalized, bytes: encodedBytes };
+    };
+    const normalized = visit(value, 0, '$', resolvedLimits.maxBytes).value;
+    if (Buffer.byteLength(JSON.stringify(normalized)) <= resolvedLimits.maxBytes) {
+        return normalized;
+    }
+    return makeDescription('truncated', { reason: 'bytes' });
+}
+function assertJsonSerializableAt(value, path, seen) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new FlexHarnessStoreFormatError(`${path} contains a non-finite number.`);
+        }
+        return;
+    }
+    if (typeof value !== 'object') {
+        throw new FlexHarnessStoreFormatError(`${path} contains ${typeof value}, which is not JSON-safe.`);
+    }
+    if (seen.has(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} contains a circular reference.`);
+    }
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} contains a non-plain object.`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new FlexHarnessStoreFormatError(`${path} contains a symbol-keyed property.`);
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const extraKey = Object.keys(value).find((key) => !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length);
+        if (extraKey) {
+            throw new FlexHarnessStoreFormatError(`${path}.${extraKey} is not a JSON array index.`);
+        }
+        const customHiddenKey = Object.getOwnPropertyNames(value).find((key) => key !== 'length' && !/^(0|[1-9]\d*)$/.test(key));
+        if (customHiddenKey) {
+            throw new FlexHarnessStoreFormatError(`${path}.${customHiddenKey} is not JSON-visible.`);
+        }
+        for (let index = 0; index < value.length; index++) {
+            if (!(index in value)) {
+                throw new FlexHarnessStoreFormatError(`${path}[${index}] is a sparse array entry.`);
+            }
+            assertJsonSerializableAt(value[index], `${path}[${index}]`, seen);
+        }
+    }
+    else {
+        for (const key of Object.getOwnPropertyNames(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor.enumerable || !('value' in descriptor)) {
+                throw new FlexHarnessStoreFormatError(`${path}.${key} is not a plain JSON property.`);
+            }
+            assertJsonSerializableAt(descriptor.value, `${path}.${key}`, seen);
+        }
+    }
+    seen.delete(value);
+}
+export function assertJsonSerializable(value, path = '$') {
+    assertJsonSerializableAt(value, path, new WeakSet());
+}
+function requireRecord(value, path) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !isPlainObject(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a plain object.`);
+    }
+    return value;
+}
+function requireString(value, path) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a non-empty string.`);
+    }
+    return value;
+}
+function requireOptionalString(value, path) {
+    if (value !== undefined)
+        requireString(value, path);
+}
+function requireNonNegativeNumber(value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new FlexHarnessStoreFormatError(`${path} must be a non-negative finite number.`);
+    }
+}
+function requireStringArray(value, path) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new FlexHarnessStoreFormatError(`${path} must be an array of strings.`);
+    }
+    return value;
+}
+function validateSessionSnapshot(value, path) {
+    const stored = requireRecord(value, path);
+    const session = requireRecord(stored.session, `${path}.session`);
+    const sessionId = requireString(session.sessionId, `${path}.session.sessionId`);
+    requireString(session.scopeId, `${path}.session.scopeId`);
+    requireString(session.createdAt, `${path}.session.createdAt`);
+    requireString(session.updatedAt, `${path}.session.updatedAt`);
+    requireOptionalString(session.title, `${path}.session.title`);
+    requireOptionalString(session.archivedAt, `${path}.session.archivedAt`);
+    if (!['idle', 'running', 'waiting_permission', 'failed', 'cancelled'].includes(String(session.status))) {
+        throw new FlexHarnessStoreFormatError(`${path}.session.status is invalid.`);
+    }
+    const activity = requireRecord(session.activity, `${path}.session.activity`);
+    if (!['idle', 'running', 'waiting_permission', 'failed', 'cancelled'].includes(String(activity.status))) {
+        throw new FlexHarnessStoreFormatError(`${path}.session.activity.status is invalid.`);
+    }
+    requireOptionalString(activity.runId, `${path}.session.activity.runId`);
+    requireOptionalString(activity.startedAt, `${path}.session.activity.startedAt`);
+    requireOptionalString(activity.completedAt, `${path}.session.activity.completedAt`);
+    requireOptionalString(activity.error, `${path}.session.activity.error`);
+    if (!Array.isArray(stored.messages)) {
+        throw new FlexHarnessStoreFormatError(`${path}.messages must be an array.`);
+    }
+    const messageIds = new Set();
+    for (let index = 0; index < stored.messages.length; index++) {
+        const messagePath = `${path}.messages[${index}]`;
+        const message = requireRecord(stored.messages[index], messagePath);
+        const messageId = requireString(message.messageId, `${messagePath}.messageId`);
+        if (messageIds.has(messageId)) {
+            throw new FlexHarnessStoreFormatError(`${path}.messages contains duplicate message "${messageId}".`);
+        }
+        messageIds.add(messageId);
+        if (requireString(message.sessionId, `${messagePath}.sessionId`) !== sessionId) {
+            throw new FlexHarnessStoreFormatError(`${messagePath}.sessionId does not match its session.`);
+        }
+        requireString(message.runId, `${messagePath}.runId`);
+        requireString(message.createdAt, `${messagePath}.createdAt`);
+        requireOptionalString(message.completedAt, `${messagePath}.completedAt`);
+        requireOptionalString(message.error, `${messagePath}.error`);
+        if (!['user', 'assistant'].includes(String(message.role))) {
+            throw new FlexHarnessStoreFormatError(`${messagePath}.role is invalid.`);
+        }
+        if (!['streaming', 'completed', 'failed', 'cancelled'].includes(String(message.status))) {
+            throw new FlexHarnessStoreFormatError(`${messagePath}.status is invalid.`);
+        }
+        if (!Array.isArray(message.parts)) {
+            throw new FlexHarnessStoreFormatError(`${messagePath}.parts must be an array.`);
+        }
+        if (message.model !== undefined) {
+            const model = requireRecord(message.model, `${messagePath}.model`);
+            requireString(model.provider, `${messagePath}.model.provider`);
+            requireString(model.model, `${messagePath}.model.model`);
+            requireOptionalString(model.displayName, `${messagePath}.model.displayName`);
+        }
+        if (message.usage !== undefined) {
+            const usage = requireRecord(message.usage, `${messagePath}.usage`);
+            requireNonNegativeNumber(usage.inputTokens, `${messagePath}.usage.inputTokens`);
+            requireNonNegativeNumber(usage.outputTokens, `${messagePath}.usage.outputTokens`);
+            requireNonNegativeNumber(usage.totalTokens, `${messagePath}.usage.totalTokens`);
+            requireNonNegativeNumber(usage.cacheReadTokens, `${messagePath}.usage.cacheReadTokens`);
+            requireNonNegativeNumber(usage.cacheWriteTokens, `${messagePath}.usage.cacheWriteTokens`);
+        }
+        const partIds = new Set();
+        for (let partIndex = 0; partIndex < message.parts.length; partIndex++) {
+            const partPath = `${messagePath}.parts[${partIndex}]`;
+            const part = requireRecord(message.parts[partIndex], partPath);
+            const partId = requireString(part.partId, `${partPath}.partId`);
+            if (partIds.has(partId)) {
+                throw new FlexHarnessStoreFormatError(`${messagePath}.parts contains duplicate part "${partId}".`);
+            }
+            partIds.add(partId);
+            if (!['text', 'reasoning', 'tool', 'attachment'].includes(String(part.type))) {
+                throw new FlexHarnessStoreFormatError(`${partPath}.type is invalid.`);
+            }
+            if (part.type === 'text') {
+                if (typeof part.text !== 'string') {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.text must be a string.`);
+                }
+            }
+            else if (part.type === 'reasoning') {
+                if (typeof part.text !== 'string') {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.text must be a string.`);
+                }
+                if (!['running', 'completed', 'cancelled'].includes(String(part.status))) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.status is invalid.`);
+                }
+            }
+            else if (part.type === 'tool') {
+                requireString(part.toolCallId, `${partPath}.toolCallId`);
+                requireString(part.toolName, `${partPath}.toolName`);
+                if (!['running', 'completed', 'failed', 'cancelled'].includes(String(part.status))) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.status is invalid.`);
+                }
+                if (!Object.prototype.hasOwnProperty.call(part, 'input')) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.input is required.`);
+                }
+                requireOptionalString(part.error, `${partPath}.error`);
+            }
+            else {
+                const unsupportedAttachmentField = Object.keys(part).find((key) => ![
+                    'partId',
+                    'type',
+                    'attachmentType',
+                    'source',
+                    'sizeBytes',
+                    'mediaType',
+                    'name',
+                ].includes(key));
+                if (unsupportedAttachmentField) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.${unsupportedAttachmentField} is not public attachment metadata.`);
+                }
+                if (!['image', 'file'].includes(String(part.attachmentType))) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.attachmentType is invalid.`);
+                }
+                if (!['inline-base64', 'data-url', 'remote-url'].includes(String(part.source))) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.source is invalid.`);
+                }
+                if (part.sizeBytes !== undefined &&
+                    (!Number.isSafeInteger(part.sizeBytes) || Number(part.sizeBytes) < 0)) {
+                    throw new FlexHarnessStoreFormatError(`${partPath}.sizeBytes must be a non-negative integer.`);
+                }
+                requireOptionalString(part.mediaType, `${partPath}.mediaType`);
+                requireOptionalString(part.name, `${partPath}.name`);
+            }
+        }
+    }
+    if (!Array.isArray(stored.modelHistory)) {
+        throw new FlexHarnessStoreFormatError(`${path}.modelHistory must be an array.`);
+    }
+    for (let index = 0; index < stored.modelHistory.length; index++) {
+        const historyPath = `${path}.modelHistory[${index}]`;
+        const message = requireRecord(stored.modelHistory[index], historyPath);
+        if (!['system', 'user', 'assistant', 'tool'].includes(String(message.role))) {
+            throw new FlexHarnessStoreFormatError(`${historyPath}.role is invalid.`);
+        }
+        if (typeof message.content !== 'string' && !Array.isArray(message.content)) {
+            throw new FlexHarnessStoreFormatError(`${historyPath}.content is invalid.`);
+        }
+    }
+    const rememberedPermissionKeys = requireStringArray(stored.rememberedPermissionKeys, `${path}.rememberedPermissionKeys`);
+    if (rememberedPermissionKeys.some((key) => key.length === 0)) {
+        throw new FlexHarnessStoreFormatError(`${path}.rememberedPermissionKeys contains an empty key.`);
+    }
+    if (new Set(rememberedPermissionKeys).size !== rememberedPermissionKeys.length) {
+        throw new FlexHarnessStoreFormatError(`${path}.rememberedPermissionKeys contains duplicate keys.`);
+    }
+    return sessionId;
+}
+export function assertFlexHarnessSnapshot(value) {
+    assertJsonSerializable(value, '$snapshot');
+    const snapshot = requireRecord(value, '$snapshot');
+    if (snapshot.schemaVersion !== 1) {
+        throw new FlexHarnessStoreFormatError('Snapshot schemaVersion must be 1.');
+    }
+    if (!Number.isSafeInteger(snapshot.revision) || Number(snapshot.revision) < 0) {
+        throw new FlexHarnessStoreFormatError('Snapshot revision must be a non-negative integer.');
+    }
+    if (!Array.isArray(snapshot.sessions)) {
+        throw new FlexHarnessStoreFormatError('Snapshot sessions must be an array.');
+    }
+    const sessionIds = new Set();
+    for (let index = 0; index < snapshot.sessions.length; index++) {
+        const sessionId = validateSessionSnapshot(snapshot.sessions[index], `$snapshot.sessions[${index}]`);
+        if (sessionIds.has(sessionId)) {
+            throw new FlexHarnessStoreFormatError(`Snapshot contains duplicate session "${sessionId}".`);
+        }
+        sessionIds.add(sessionId);
+    }
+}
+export function cloneSerializable(value) {
+    assertJsonSerializable(value);
+    return JSON.parse(JSON.stringify(value));
+}
+export function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const entry of Object.values(value)) {
+        deepFreeze(entry);
+    }
+    return Object.freeze(value);
+}
+function serializeModelValue(value, path, seen) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value))) {
+        return value;
+    }
+    if (typeof value === 'undefined') {
+        return undefined;
+    }
+    if (typeof value !== 'object') {
+        throw new FlexHarnessStoreFormatError(`${path} contains a non-serializable model value.`);
+    }
+    if (value instanceof URL) {
+        return value.toString();
+    }
+    const bytes = binaryBytes(value);
+    if (bytes) {
+        return Buffer.from(bytes).toString('base64');
+    }
+    if (seen.has(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} contains a circular model value.`);
+    }
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        throw new FlexHarnessStoreFormatError(`${path} contains a non-plain model value.`);
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const result = value.map((entry, index) => {
+            const serialized = serializeModelValue(entry, `${path}[${index}]`, seen);
+            if (serialized === undefined) {
+                throw new FlexHarnessStoreFormatError(`${path}[${index}] is undefined.`);
+            }
+            return serialized;
+        });
+        seen.delete(value);
+        return result;
+    }
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const serialized = serializeModelValue(entry, `${path}.${key}`, seen);
+        if (serialized !== undefined) {
+            result[key] = serialized;
+        }
+    }
+    seen.delete(value);
+    return result;
+}
+export function serializeAgentMessages(messages) {
+    const serialized = serializeModelValue(messages, '$messages', new WeakSet());
+    assertJsonSerializable(serialized, '$messages');
+    return serialized;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.json.js","sourceRoot":"","sources":["../ts/utils.json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAQtF,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAC7B,MAAM,iBAAiB,GAAG,GAAG,GAAG,IAAI,CAAC;AACrC,MAAM,aAAa,GAAG,GAAG,CAAC;AAE1B,SAAS,aAAa,CAAC,KAAa;IAClC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC/C,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC;AAC9D,CAAC;AAED,SAAS,eAAe,CAAC,IAAY,EAAE,SAAqC,EAAE;IAC5E,OAAO;QACL,SAAS,EAAE,IAAI;QACf,GAAG,MAAM;KACV,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,KAAa;IAChC,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QACjC,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,SAA0B,EAAE;IAC5D,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,iBAAiB,CAAC;IACtD,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,iBAAiB,CAAC;IACtD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,0BAA0B,CAAC,uDAAuD,CAAC,CAAC;IAChG,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,aAAa,EAAE,CAAC;QAChE,MAAM,IAAI,0BAA0B,CAClC,4DAA4D,aAAa,GAAG,CAC7E,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAc,EAAE,SAA0B,EAAE;IAC7E,MAAM,cAAc,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,IAAI,OAAO,EAAkB,CAAC;IAO3C,MAAM,OAAO,GAAG,CAAC,KAAiB,EAAgB,EAAE,CAAC,CAAC;QACpD,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;KAChD,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,CAAC,KAAa,EAAE,iBAAiB,GAAG,GAAG,EAAU,EAAE,CACrE,KAAK,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IACvF,MAAM,WAAW,GAAG,CAClB,IAAY,EACZ,MAAkC,EAClC,SAAiB,EACH,EAAE;QAChB,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;QACxD,IAAI,QAAQ,CAAC,KAAK,IAAI,SAAS;YAAE,OAAO,QAAQ,CAAC;QACjD,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;QAC3E,IAAI,OAAO,CAAC,KAAK,IAAI,SAAS;YAAE,OAAO,OAAO,CAAC;QAC/C,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,CAAC,CAAC;IACF,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,MAAc,EAAU,EAAE,CACxD,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;IAE/C,MAAM,KAAK,GAAG,CACZ,OAAgB,EAChB,KAAa,EACb,IAAY,EACZ,SAAiB,EACH,EAAE;QAChB,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC;QAC9E,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YAC5C,IAAI,QAAQ,GAAG,CAAC,GAAG,SAAS,EAAE,CAAC;gBAC7B,OAAO,WAAW,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;YACxF,CAAC;YACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;YACjC,OAAO,OAAO,CAAC,KAAK,IAAI,SAAS;gBAC/B,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;QACrF,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAC7B,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;gBAClB,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;QACnE,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,WAAW,EAAE,CAAC;YACnC,OAAO,WAAW,CAAC,WAAW,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,WAAW,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACvC,OAAO,WAAW,CAChB,QAAQ,EACR,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,SAAS,GAAG,CAAC;gBAC5C,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE;gBACxB,CAAC,CAAC,EAAE,WAAW,EAAE,8BAA8B,EAAE,EACnD,SAAS,CACV,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAClC,OAAO,WAAW,CAChB,UAAU,EACV;gBACE,WAAW,EAAE,OAAO,CAAC,IAAI;oBACvB,CAAC,CAAC,aAAa,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG;oBAC3C,CAAC,CAAC,sBAAsB;aAC3B,EACD,SAAS,CACV,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,KAAK,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;YACrC,OAAO,WAAW,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;QAC3F,CAAC;QAED,MAAM,WAAW,GAAG,OAAiB,CAAC;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,WAAW,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,SAAS,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,OAAO,YAAY,IAAI,EAAE,CAAC;YAC5B,OAAO,WAAW,CAChB,MAAM,EACN,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,EACnF,SAAS,CACV,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,YAAY,GAAG,EAAE,CAAC;YAC3B,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrC,OAAO,WAAW,CAChB,KAAK,EACL,EAAE,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,GAAG,GAAG,EAAE,EACpE,SAAS,CACV,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;QACxC,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YAC5E,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;YACxD,OAAO,WAAW,CAChB,QAAQ,EACR;gBACE,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAC9C,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,SAAS,EAAE,QAAQ,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU;aACnD,EACD,SAAS,CACV,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,YAAY,KAAK,EAAE,CAAC;YAC7B,OAAO,WAAW,CAChB,OAAO,EACP,EAAE,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAC1E,SAAS,CACV,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,YAAY,MAAM,EAAE,CAAC;YAC9B,OAAO,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;QACtF,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAC5B,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,MAAM,UAAU,GAAiB,EAAE,CAAC;YACpC,IAAI,YAAY,GAAG,CAAC,CAAC;YACrB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;gBACpD,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACrD,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;gBAC9C,MAAM,UAAU,GAAG,WAAW,CAC5B,WAAW,EACX,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,EACjD,SAAS,CACV,CAAC;gBACF,MAAM,iBAAiB,GAAG,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC;oBAClD,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK;oBACtB,CAAC,CAAC,CAAC,CAAC;gBACN,MAAM,cAAc,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,GAAG,iBAAiB,CAAC;gBACrF,IAAI,cAAc,GAAG,EAAE,EAAE,CAAC;oBACxB,IAAI,YAAY,GAAG,cAAc,GAAG,UAAU,CAAC,KAAK,IAAI,SAAS,EAAE,CAAC;wBAClE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;wBAClC,YAAY,IAAI,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;oBACpD,CAAC;oBACD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;gBACpD,CAAC;gBACD,IAAI,KAAc,CAAC;gBACnB,IAAI,CAAC;oBACH,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;gBACzB,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,KAAK,GAAG,eAAe,CAAC,YAAY,EAAE;wBACpC,WAAW,EAAE,WAAW,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;qBACjF,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM,KAAK,GAAG,KAAK,CACjB,KAAK,EACL,KAAK,GAAG,CAAC,EACT,QAAQ,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,CAAC,EAC5B,cAAc,CACf,CAAC;gBACF,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC7B,YAAY,IAAI,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC;YAC/C,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;YAChC,MAAM,eAAe,GAAG,WAAW,CAAC,WAAW,EAAE,IAAI,IAAI,QAAQ,CAAC;YAClE,OAAO,WAAW,CAChB,QAAQ,EACR,EAAE,WAAW,EAAE,IAAI,WAAW,CAAC,eAAe,CAAC,GAAG,EAAE,EACpD,SAAS,CACV,CAAC;QACJ,CAAC;QAED,MAAM,UAAU,GAA+B,EAAE,CAAC;QAClD,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,iBAAiB,GAAG,CAAC,CAAC;QAC1B,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,IAAI,aAAa,GAAG,gBAAgB,CAAC;QACrC,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,CAAC;YACpE,aAAa,IAAI,GAAG,CAAC;QACvB,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC;gBAAE,SAAS;YAClE,MAAM,cAAc,GAAG,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,UAAU,GAAG,WAAW,CAC5B,WAAW,EACX,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,EACtC,SAAS,CACV,CAAC;YACF,MAAM,uBAAuB,GAC3B,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC/B,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;gBAChD,CAAC;gBACD,UAAU,CAAC,KAAK,CAAC;YACnB,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAC3C,IAAI,WAAW,GAAG,CAAC,IAAI,SAAS,GAAG,YAAY,GAAG,uBAAuB,EAAE,CAAC;gBAC1E,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,CAAC;YACD,MAAM,eAAe,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;YAC/D,MAAM,cAAc,GAClB,SAAS;gBACT,YAAY;gBACZ,cAAc;gBACd,eAAe;gBACf,CAAC;gBACD,uBAAuB,CAAC;YAC1B,IAAI,cAAc,GAAG,EAAE,EAAE,CAAC;gBACxB,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,CAAC;YACD,IAAI,KAAc,CAAC;YACnB,IAAI,CAAC;gBACH,KAAK,GAAI,OAAmC,CAAC,GAAG,CAAC,CAAC;YACpD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,KAAK,GAAG,eAAe,CAAC,YAAY,EAAE;oBACpC,WAAW,EAAE,WAAW,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;iBACjF,CAAC,CAAC;YACL,CAAC;YACD,MAAM,KAAK,GAAG,KAAK,CACjB,KAAK,EACL,KAAK,GAAG,CAAC,EACT,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,EACzB,cAAc,CACf,CAAC;YACF,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;YAC9B,YAAY,IAAI,cAAc,GAAG,eAAe,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;YACnE,iBAAiB,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,UAAU,GAAG,WAAW,CAC5B,WAAW,EACX,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,EACtC,SAAS,CACV,CAAC;YACF,MAAM,cAAc,GAAG,iBAAiB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,UAAU,CAAC,aAAa,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;YAC7C,YAAY;gBACV,cAAc;oBACd,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;oBAChD,CAAC;oBACD,UAAU,CAAC,KAAK,CAAC;QACrB,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;IACpD,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC;IACvE,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,CAAC;QAC7E,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,OAAO,eAAe,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAc,EAAE,IAAY,EAAE,IAAqB;IACnF,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC9E,OAAO;IACT,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,gCAAgC,CAAC,CAAC;QACjF,CAAC;QACD,OAAO;IACT,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,aAAa,OAAO,KAAK,2BAA2B,CAAC,CAAC;IACrG,CAAC;IACD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,iCAAiC,CAAC,CAAC;IAClF,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,+BAA+B,CAAC,CAAC;IAChF,CAAC;IACD,IAAI,MAAM,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,oCAAoC,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CACtC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CACpE,CAAC;QACF,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,IAAI,QAAQ,6BAA6B,CAAC,CAAC;QAC1F,CAAC;QACD,MAAM,eAAe,GAAG,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,IAAI,CAC5D,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CACzD,CAAC;QACF,IAAI,eAAe,EAAE,CAAC;YACpB,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,IAAI,eAAe,uBAAuB,CAAC,CAAC;QAC3F,CAAC;QACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YAClD,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,IAAI,KAAK,4BAA4B,CAAC,CAAC;YACtF,CAAC;YACD,wBAAwB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;SAAM,CAAC;QACN,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACpD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAE,CAAC;YAChE,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC;gBACvD,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,IAAI,GAAG,gCAAgC,CAAC,CAAC;YACxF,CAAC;YACD,wBAAwB,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,KAAc,EAAE,IAAI,GAAG,GAAG;IAC/D,wBAAwB,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,OAAO,EAAU,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,aAAa,CAAC,KAAc,EAAE,IAAY;IACjD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACzF,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,0BAA0B,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,KAAgC,CAAC;AAC1C,CAAC;AAED,SAAS,aAAa,CAAC,KAAc,EAAE,IAAY;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,8BAA8B,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAc,EAAE,IAAY;IACzD,IAAI,KAAK,KAAK,SAAS;QAAE,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAc,EAAE,IAAY;IAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,wCAAwC,CAAC,CAAC;IACzF,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc,EAAE,IAAY;IACtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC9E,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,+BAA+B,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,uBAAuB,CAAC,KAAc,EAAE,IAAY;IAC3D,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC1C,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,IAAI,UAAU,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,IAAI,oBAAoB,CAAC,CAAC;IAChF,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,kBAAkB,CAAC,CAAC;IAC1D,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,IAAI,oBAAoB,CAAC,CAAC;IAC9D,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,IAAI,oBAAoB,CAAC,CAAC;IAC9D,qBAAqB,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,gBAAgB,CAAC,CAAC;IAC9D,qBAAqB,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,IAAI,qBAAqB,CAAC,CAAC;IACxE,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,oBAAoB,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACvG,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,6BAA6B,CAAC,CAAC;IAC9E,CAAC;IACD,MAAM,QAAQ,GAAG,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,IAAI,mBAAmB,CAAC,CAAC;IAC7E,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,oBAAoB,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACxG,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,sCAAsC,CAAC,CAAC;IACvF,CAAC;IACD,qBAAqB,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,IAAI,yBAAyB,CAAC,CAAC;IACxE,qBAAqB,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,IAAI,6BAA6B,CAAC,CAAC;IAChF,qBAAqB,CAAC,QAAQ,CAAC,WAAW,EAAE,GAAG,IAAI,+BAA+B,CAAC,CAAC;IACpF,qBAAqB,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,IAAI,yBAAyB,CAAC,CAAC;IAExE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,6BAA6B,CAAC,CAAC;IAC9E,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC5D,MAAM,WAAW,GAAG,GAAG,IAAI,aAAa,KAAK,GAAG,CAAC;QACjD,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;QACnE,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,WAAW,YAAY,CAAC,CAAC;QAC/E,IAAI,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,yCAAyC,SAAS,IAAI,CAAC,CAAC;QACvG,CAAC;QACD,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1B,IAAI,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,WAAW,YAAY,CAAC,KAAK,SAAS,EAAE,CAAC;YAC/E,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,wCAAwC,CAAC,CAAC;QAChG,CAAC;QACD,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,WAAW,QAAQ,CAAC,CAAC;QACrD,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,WAAW,YAAY,CAAC,CAAC;QAC7D,qBAAqB,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,WAAW,cAAc,CAAC,CAAC;QACzE,qBAAqB,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,WAAW,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,mBAAmB,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,CAAC,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;YACxF,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,qBAAqB,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,0BAA0B,CAAC,CAAC;QAClF,CAAC;QACD,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,WAAW,QAAQ,CAAC,CAAC;YACnE,aAAa,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,WAAW,iBAAiB,CAAC,CAAC;YAC/D,aAAa,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,WAAW,cAAc,CAAC,CAAC;YACzD,qBAAqB,CAAC,KAAK,CAAC,WAAW,EAAE,GAAG,WAAW,oBAAoB,CAAC,CAAC;QAC/E,CAAC;QACD,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,WAAW,QAAQ,CAAC,CAAC;YACnE,wBAAwB,CAAC,KAAK,CAAC,WAAW,EAAE,GAAG,WAAW,oBAAoB,CAAC,CAAC;YAChF,wBAAwB,CAAC,KAAK,CAAC,YAAY,EAAE,GAAG,WAAW,qBAAqB,CAAC,CAAC;YAClF,wBAAwB,CAAC,KAAK,CAAC,WAAW,EAAE,GAAG,WAAW,oBAAoB,CAAC,CAAC;YAChF,wBAAwB,CAAC,KAAK,CAAC,eAAe,EAAE,GAAG,WAAW,wBAAwB,CAAC,CAAC;YACxF,wBAAwB,CAAC,KAAK,CAAC,gBAAgB,EAAE,GAAG,WAAW,yBAAyB,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAClC,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC;YACtE,MAAM,QAAQ,GAAG,GAAG,WAAW,UAAU,SAAS,GAAG,CAAC;YACtD,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,CAAC;YAC/D,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,QAAQ,SAAS,CAAC,CAAC;YAChE,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;gBACxB,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,mCAAmC,MAAM,IAAI,CAAC,CAAC;YACrG,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACpB,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;gBAC7E,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,mBAAmB,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBACzB,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAClC,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,yBAAyB,CAAC,CAAC;gBAC9E,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBACrC,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAClC,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,yBAAyB,CAAC,CAAC;gBAC9E,CAAC;gBACD,IAAI,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBACzE,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,qBAAqB,CAAC,CAAC;gBAC1E,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBAChC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,QAAQ,aAAa,CAAC,CAAC;gBACzD,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,QAAQ,WAAW,CAAC,CAAC;gBACrD,IAAI,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBACnF,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,qBAAqB,CAAC,CAAC;gBAC1E,CAAC;gBACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;oBACzD,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,qBAAqB,CAAC,CAAC;gBAC1E,CAAC;gBACD,qBAAqB,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,QAAQ,QAAQ,CAAC,CAAC;YACzD,CAAC;iBAAM,CAAC;gBACN,MAAM,0BAA0B,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CACvD,CAAC,GAAG,EAAE,EAAE,CACN,CAAC;oBACC,QAAQ;oBACR,MAAM;oBACN,gBAAgB;oBAChB,QAAQ;oBACR,WAAW;oBACX,WAAW;oBACX,MAAM;iBACP,CAAC,QAAQ,CAAC,GAAG,CAAC,CAClB,CAAC;gBACF,IAAI,0BAA0B,EAAE,CAAC;oBAC/B,MAAM,IAAI,2BAA2B,CACnC,GAAG,QAAQ,IAAI,0BAA0B,qCAAqC,CAC/E,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;oBAC7D,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,6BAA6B,CAAC,CAAC;gBAClF,CAAC;gBACD,IAAI,CAAC,CAAC,eAAe,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBAC/E,MAAM,IAAI,2BAA2B,CAAC,GAAG,QAAQ,qBAAqB,CAAC,CAAC;gBAC1E,CAAC;gBACD,IACE,IAAI,CAAC,SAAS,KAAK,SAAS;oBAC5B,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EACrE,CAAC;oBACD,MAAM,IAAI,2BAA2B,CACnC,GAAG,QAAQ,4CAA4C,CACxD,CAAC;gBACJ,CAAC;gBACD,qBAAqB,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,QAAQ,YAAY,CAAC,CAAC;gBAC/D,qBAAqB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,QAAQ,OAAO,CAAC,CAAC;YACvD,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,iCAAiC,CAAC,CAAC;IAClF,CAAC;IACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAChE,MAAM,WAAW,GAAG,GAAG,IAAI,iBAAiB,KAAK,GAAG,CAAC;QACrD,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;QACvE,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC5E,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,mBAAmB,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3E,MAAM,IAAI,2BAA2B,CAAC,GAAG,WAAW,sBAAsB,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;IACD,MAAM,wBAAwB,GAAG,kBAAkB,CACjD,MAAM,CAAC,wBAAwB,EAC/B,GAAG,IAAI,2BAA2B,CACnC,CAAC;IACF,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,kDAAkD,CAAC,CAAC;IACnG,CAAC;IACD,IAAI,IAAI,GAAG,CAAC,wBAAwB,CAAC,CAAC,IAAI,KAAK,wBAAwB,CAAC,MAAM,EAAE,CAAC;QAC/E,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,oDAAoD,CAAC,CAAC;IACrG,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,KAAc;IACtD,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAC3C,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACnD,IAAI,QAAQ,CAAC,aAAa,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,2BAA2B,CAAC,mCAAmC,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9E,MAAM,IAAI,2BAA2B,CAAC,mDAAmD,CAAC,CAAC;IAC7F,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,2BAA2B,CAAC,qCAAqC,CAAC,CAAC;IAC/E,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;IACrC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC9D,MAAM,SAAS,GAAG,uBAAuB,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,sBAAsB,KAAK,GAAG,CAAC,CAAC;QACpG,IAAI,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,2BAA2B,CAAC,wCAAwC,SAAS,IAAI,CAAC,CAAC;QAC/F,CAAC;QACD,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC5B,CAAC;AACH,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAI,KAAQ;IAC3C,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAM,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,UAAU,CAAI,KAAQ;IACpC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAClE,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACzC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAc,EAAE,IAAY,EAAE,IAAqB;IAC9E,IACE,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS;QAC1B,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EACrD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,WAAW,EAAE,CAAC;QACjC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,2CAA2C,CAAC,CAAC;IAC5F,CAAC;IACD,IAAI,KAAK,YAAY,GAAG,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;IACD,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;IACjC,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC/C,CAAC;IACD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,mCAAmC,CAAC,CAAC;IACpF,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,oCAAoC,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACxC,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,IAAI,CAAC,CAAC;YACzE,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC7B,MAAM,IAAI,2BAA2B,CAAC,GAAG,IAAI,IAAI,KAAK,iBAAiB,CAAC,CAAC;YAC3E,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,MAAM,MAAM,GAA4B,EAAE,CAAC;IAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;QACtE,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,QAAkC;IAElC,MAAM,UAAU,GAAG,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,IAAI,OAAO,EAAU,CAAC,CAAC;IACrF,sBAAsB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAChD,OAAO,UAAsC,CAAC;AAChD,CAAC"}

package/dist_ts/utils.prompt.d.ts

@@ -0,0 +1,8 @@
+import type { TFlexAgentModelMessage, TFlexAgentPrompt, TFlexPrompt, TFlexPromptPart } from './interfaces.js';
+export interface INormalizedFlexPrompt {
+    agentPrompt: TFlexAgentPrompt;
+    modelMessage: TFlexAgentModelMessage;
+    parts: TFlexPromptPart[];
+}
+export declare function normalizeFlexPrompt(prompt: TFlexPrompt): INormalizedFlexPrompt;
+export declare function hydrateAgentMessages(messages: TFlexAgentModelMessage[]): TFlexAgentModelMessage[];