@modelprofile.com/flexharness 4.1.0 → 4.1.1

package/dist_ts/utils.tooloutput.js

@@ -0,0 +1,56 @@
+import { normalizeJsonValue } from './utils.json.js';
+function isAsyncIterable(value) {
+    return Boolean(value
+        && (typeof value === 'object' || typeof value === 'function')
+        && typeof value[Symbol.asyncIterator] === 'function');
+}
+async function* normalizeAsyncIterable(iterable, limits, projectError) {
+    try {
+        for await (const value of iterable)
+            yield normalizeJsonValue(value, limits);
+    }
+    catch (error) {
+        throw projectError(error);
+    }
+}
+export function wrapToolSet(tools, limits, projectError) {
+    const wrapped = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        const toolRecord = tool;
+        if (typeof toolRecord.execute !== 'function') {
+            wrapped[name] = tool;
+            continue;
+        }
+        const execute = toolRecord.execute;
+        wrapped[name] = {
+            ...toolRecord,
+            execute(input, options) {
+                let output;
+                try {
+                    output = execute.call(tool, input, options);
+                    if (isAsyncIterable(output)) {
+                        return normalizeAsyncIterable(output, limits, projectError);
+                    }
+                }
+                catch (error) {
+                    throw projectError(error);
+                }
+                return Promise.resolve(output).then((value) => {
+                    try {
+                        if (isAsyncIterable(value)) {
+                            return normalizeAsyncIterable(value, limits, projectError);
+                        }
+                        return normalizeJsonValue(value, limits);
+                    }
+                    catch (error) {
+                        throw projectError(error);
+                    }
+                }, (error) => {
+                    throw projectError(error);
+                });
+            },
+        };
+    }
+    return wrapped;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMudG9vbG91dHB1dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3V0aWxzLnRvb2xvdXRwdXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFNckQsU0FBUyxlQUFlLENBQUMsS0FBYztJQUNyQyxPQUFPLE9BQU8sQ0FDWixLQUFLO1dBQ0YsQ0FBQyxPQUFPLEtBQUssS0FBSyxRQUFRLElBQUksT0FBTyxLQUFLLEtBQUssVUFBVSxDQUFDO1dBQzFELE9BQVEsS0FBOEMsQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQUssVUFBVSxDQUMvRixDQUFDO0FBQ0osQ0FBQztBQUVELEtBQUssU0FBUyxDQUFDLENBQUMsc0JBQXNCLENBQ3BDLFFBQWdDLEVBQ2hDLE1BQStFLEVBQy9FLFlBQXVDO0lBRXZDLElBQUksQ0FBQztRQUNILElBQUksS0FBSyxFQUFFLE1BQU0sS0FBSyxJQUFJLFFBQVE7WUFBRSxNQUFNLGtCQUFrQixDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLE1BQU0sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzVCLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLFdBQVcsQ0FDekIsS0FBd0IsRUFDeEIsTUFBK0UsRUFDL0UsWUFBdUM7SUFFdkMsTUFBTSxPQUFPLEdBQTRCLEVBQUUsQ0FBQztJQUM1QyxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ2pELE1BQU0sVUFBVSxHQUFHLElBQXdDLENBQUM7UUFDNUQsSUFBSSxPQUFPLFVBQVUsQ0FBQyxPQUFPLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDN0MsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQztZQUNyQixTQUFTO1FBQ1gsQ0FBQztRQUNELE1BQU0sT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDbkMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHO1lBQ2QsR0FBRyxVQUFVO1lBQ2IsT0FBTyxDQUFDLEtBQWMsRUFBRSxPQUFnQjtnQkFDdEMsSUFBSSxNQUFlLENBQUM7Z0JBQ3BCLElBQUksQ0FBQztvQkFDSCxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO29CQUM1QyxJQUFJLGVBQWUsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO3dCQUM1QixPQUFPLHNCQUFzQixDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsWUFBWSxDQUFDLENBQUM7b0JBQzlELENBQUM7Z0JBQ0gsQ0FBQztnQkFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO29CQUNmLE1BQU0sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUM1QixDQUFDO2dCQUNELE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQ2pDLENBQUMsS0FBSyxFQUFFLEVBQUU7b0JBQ1IsSUFBSSxDQUFDO3dCQUNILElBQUksZUFBZSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7NEJBQzNCLE9BQU8sc0JBQXNCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQzt3QkFDN0QsQ0FBQzt3QkFDRCxPQUFPLGtCQUFrQixDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztvQkFDM0MsQ0FBQztvQkFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO3dCQUNmLE1BQU0sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO29CQUM1QixDQUFDO2dCQUNILENBQUMsRUFDRCxDQUFDLEtBQWMsRUFBRSxFQUFFO29CQUNqQixNQUFNLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDNUIsQ0FBQyxDQUNGLENBQUM7WUFDSixDQUFDO1NBQ0YsQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLE9BQTRCLENBQUM7QUFDdEMsQ0FBQyJ9

package/dist_ts/utils.transfer.d.ts

@@ -0,0 +1,24 @@
+import type { IFlexAttachmentMessagePart, IFlexMessage, IFlexModelIdentity, IFlexResolvedModel, IFlexUsage, TFlexAgentRunResult, TFlexPromptPart } from './interfaces.js';
+export interface IRunResultProjection {
+    text: string;
+    steps: number;
+    finishReason: string;
+    usage: IFlexUsage;
+}
+export declare const maxMessagePageSize = 50;
+export declare const maxMessagePageCursorBytes = 4096;
+export declare const maxTransferIdentifierBytes = 512;
+export declare const maxTransferMetadataBytes = 2048;
+export declare const maxTransferTextBytes: number;
+export declare const maxTransferPageBytes: number;
+export declare function publicSnapshot<TValue>(value: TValue): TValue;
+export declare function jsonBytes(value: unknown): number;
+export declare function truncateUtf8(value: string, maxBytes: number): string;
+export declare function requireTransferIdentifier(value: string, field: string): void;
+export declare function normalizeModelIdentity(identity: IFlexModelIdentity): IFlexModelIdentity;
+export declare function normalizeResolvedModel(resolvedModel: IFlexResolvedModel): IFlexResolvedModel;
+export declare function normalizeRunResult(result: TFlexAgentRunResult): IRunResultProjection;
+export declare function describeAttachment(part: Exclude<TFlexPromptPart, {
+    type: 'text';
+}>): Omit<IFlexAttachmentMessagePart, 'partId' | 'type' | 'attachmentType'>;
+export declare function createBoundedTransferMessage(message: IFlexMessage): IFlexMessage;

package/dist_ts/utils.transfer.js

@@ -0,0 +1,195 @@
+import { FlexHarnessValidationError } from './errors.js';
+import { cloneSerializable, deepFreeze } from './utils.json.js';
+import { validateIdentifier } from './utils.validation.js';
+export const maxMessagePageSize = 50;
+export const maxMessagePageCursorBytes = 4096;
+export const maxTransferIdentifierBytes = 512;
+export const maxTransferMetadataBytes = 2048;
+export const maxTransferTextBytes = 96 * 1024;
+const maxTransferMessageBytes = 480 * 1024;
+export const maxTransferPageBytes = 512 * 1024;
+export function publicSnapshot(value) {
+    return deepFreeze(cloneSerializable(value));
+}
+export function jsonBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+export function truncateUtf8(value, maxBytes) {
+    if (Buffer.byteLength(value, 'utf8') <= maxBytes)
+        return value;
+    const suffix = ' [truncated]';
+    const suffixBytes = Buffer.byteLength(suffix, 'utf8');
+    let truncated = Buffer.from(value, 'utf8')
+        .subarray(0, Math.max(0, maxBytes - suffixBytes))
+        .toString('utf8')
+        .replace(/\uFFFD$/u, '');
+    while (Buffer.byteLength(`${truncated}${suffix}`, 'utf8') > maxBytes) {
+        truncated = truncated.slice(0, -1);
+    }
+    return `${truncated}${suffix}`;
+}
+export function requireTransferIdentifier(value, field) {
+    if (Buffer.byteLength(value, 'utf8') > maxTransferIdentifierBytes) {
+        throw new FlexHarnessValidationError(`${field} exceeds the transfer limit.`);
+    }
+}
+export function normalizeModelIdentity(identity) {
+    const normalized = {
+        provider: identity.provider,
+        model: identity.model,
+        ...(identity.displayName === undefined ? {} : { displayName: identity.displayName }),
+        ...(identity.variant === undefined ? {} : { variant: identity.variant }),
+    };
+    validateIdentifier(normalized.provider, 'model identity provider');
+    validateIdentifier(normalized.model, 'model identity model');
+    if (normalized.displayName !== undefined) {
+        validateIdentifier(normalized.displayName, 'model identity displayName');
+    }
+    if (normalized.variant !== undefined)
+        validateIdentifier(normalized.variant, 'model identity variant');
+    if (Buffer.byteLength(normalized.provider, 'utf8') > maxTransferIdentifierBytes
+        || Buffer.byteLength(normalized.model, 'utf8') > maxTransferIdentifierBytes
+        || (normalized.displayName !== undefined
+            && Buffer.byteLength(normalized.displayName, 'utf8') > maxTransferMetadataBytes)
+        || (normalized.variant !== undefined && Buffer.byteLength(normalized.variant, 'utf8') > 128)) {
+        throw new FlexHarnessValidationError('Model identity exceeds its transfer limit.');
+    }
+    return normalized;
+}
+export function normalizeResolvedModel(resolvedModel) {
+    return {
+        model: resolvedModel.model,
+        identity: normalizeModelIdentity(resolvedModel.identity),
+        ...(resolvedModel.system === undefined ? {} : { system: resolvedModel.system }),
+        ...(resolvedModel.providerOptions === undefined
+            ? {}
+            : { providerOptions: resolvedModel.providerOptions }),
+        ...(resolvedModel.cache === undefined ? {} : { cache: resolvedModel.cache }),
+        ...(resolvedModel.maxSteps === undefined ? {} : { maxSteps: resolvedModel.maxSteps }),
+    };
+}
+export function normalizeRunResult(result) {
+    const normalized = {
+        text: result.text,
+        steps: result.steps,
+        finishReason: result.finishReason,
+        usage: {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            totalTokens: result.usage.totalTokens,
+            cacheReadTokens: result.usage.cacheReadTokens,
+            cacheWriteTokens: result.usage.cacheWriteTokens,
+        },
+    };
+    if (typeof normalized.text !== 'string'
+        || typeof normalized.finishReason !== 'string'
+        || !Number.isSafeInteger(normalized.steps)
+        || normalized.steps < 0
+        || Object.values(normalized.usage).some((value) => !Number.isFinite(value) || value < 0)) {
+        throw new FlexHarnessValidationError('Agent generation result is invalid.');
+    }
+    return normalized;
+}
+function base64Size(data) {
+    const compact = data.replace(/\s/g, '');
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(compact) || compact.length % 4 === 1)
+        return undefined;
+    return Buffer.from(compact, 'base64').byteLength;
+}
+export function describeAttachment(part) {
+    let source = 'inline-base64';
+    let sizeBytes;
+    let inferredMediaType;
+    if (/^data:/i.test(part.data)) {
+        source = 'data-url';
+        const commaIndex = part.data.indexOf(',');
+        if (commaIndex >= 0) {
+            const metadata = part.data.slice(5, commaIndex);
+            const payload = part.data.slice(commaIndex + 1);
+            const metadataParts = metadata.split(';');
+            if (metadataParts[0]?.includes('/'))
+                inferredMediaType = metadataParts[0];
+            if (metadataParts.some((entry) => entry.toLowerCase() === 'base64')) {
+                sizeBytes = base64Size(payload);
+            }
+            else {
+                try {
+                    sizeBytes = Buffer.byteLength(decodeURIComponent(payload));
+                }
+                catch {
+                    // Malformed URL encoding leaves size unknown without exposing the payload.
+                }
+            }
+        }
+    }
+    else {
+        try {
+            const url = new URL(part.data);
+            if (url.protocol === 'http:' || url.protocol === 'https:')
+                source = 'remote-url';
+            else
+                sizeBytes = base64Size(part.data);
+        }
+        catch {
+            sizeBytes = base64Size(part.data);
+        }
+    }
+    return {
+        source,
+        ...(sizeBytes === undefined ? {} : { sizeBytes }),
+        ...(part.mediaType ?? inferredMediaType
+            ? { mediaType: part.mediaType ?? inferredMediaType }
+            : {}),
+        ...(part.name ? { name: part.name } : {}),
+    };
+}
+export function createBoundedTransferMessage(message) {
+    const projected = cloneSerializable(message);
+    requireTransferIdentifier(projected.messageId, 'messageId');
+    requireTransferIdentifier(projected.sessionId, 'sessionId');
+    requireTransferIdentifier(projected.runId, 'runId');
+    projected.createdAt = truncateUtf8(projected.createdAt, 128);
+    if (projected.completedAt !== undefined)
+        projected.completedAt = truncateUtf8(projected.completedAt, 128);
+    if (projected.error !== undefined)
+        projected.error = truncateUtf8(projected.error, maxTransferMetadataBytes);
+    if (projected.model) {
+        projected.model.provider = truncateUtf8(projected.model.provider, maxTransferIdentifierBytes);
+        projected.model.model = truncateUtf8(projected.model.model, maxTransferIdentifierBytes);
+        if (projected.model.displayName !== undefined) {
+            projected.model.displayName = truncateUtf8(projected.model.displayName, maxTransferMetadataBytes);
+        }
+        if (projected.model.variant !== undefined)
+            projected.model.variant = truncateUtf8(projected.model.variant, 128);
+    }
+    for (const part of projected.parts) {
+        requireTransferIdentifier(part.partId, 'partId');
+        if (part.type === 'text' || part.type === 'reasoning') {
+            part.text = truncateUtf8(part.text, maxTransferTextBytes);
+        }
+        else if (part.type === 'tool') {
+            part.toolCallId = truncateUtf8(part.toolCallId, maxTransferIdentifierBytes);
+            part.toolName = truncateUtf8(part.toolName, maxTransferIdentifierBytes);
+            if (part.error !== undefined)
+                part.error = truncateUtf8(part.error, maxTransferMetadataBytes);
+        }
+        else {
+            if (part.mediaType !== undefined)
+                part.mediaType = truncateUtf8(part.mediaType, maxTransferIdentifierBytes);
+            if (part.name !== undefined)
+                part.name = truncateUtf8(part.name, maxTransferMetadataBytes);
+        }
+    }
+    if (jsonBytes(projected) > maxTransferMessageBytes) {
+        projected.parts = [{
+                partId: 'transfer-elided',
+                type: 'text',
+                text: '[elided: message exceeds the transfer budget]',
+            }];
+    }
+    if (jsonBytes(projected) > maxTransferMessageBytes) {
+        throw new FlexHarnessValidationError('Stored message metadata exceeds the transfer limit.');
+    }
+    return projected;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.transfer.js","sourceRoot":"","sources":["../ts/utils.transfer.ts"],"names":[],"mappings":"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"}

package/dist_ts/utils.validation.d.ts

@@ -0,0 +1,13 @@
+import type { IFlexCreateProjectTaskInput, IFlexErrorInfo, IFlexPromptOptions, IFlexSlashCommandExecutionOptions, IFlexUpdateProjectTaskInput, IFlexUpdateSessionOptions, TFlexProjectTaskPriority, TFlexProjectTaskStatus } from './interfaces.js';
+export declare function validateIdentifier(value: string, name: string): void;
+export declare function validateUtf8String(value: unknown, name: string, maxBytes: number, nonEmpty?: boolean): asserts value is string;
+export declare function validateProjectedErrorInfo(value: unknown): IFlexErrorInfo;
+export declare function validateUpdateSessionOptions(options: IFlexUpdateSessionOptions): void;
+export declare function validateProjectTaskStatus(value: unknown): asserts value is TFlexProjectTaskStatus;
+export declare function validateProjectTaskPriority(value: unknown): asserts value is TFlexProjectTaskPriority;
+export declare function validateProjectTaskId(value: unknown): asserts value is string;
+export declare function validateProjectTaskContent(value: unknown): asserts value is string;
+export declare function validateCreateProjectTaskInput(input: IFlexCreateProjectTaskInput): void;
+export declare function validateUpdateProjectTaskInput(input: IFlexUpdateProjectTaskInput): void;
+export declare function validatePromptOptions(options: IFlexPromptOptions, scheduled: boolean): void;
+export declare function validateSlashCommandExecutionOptions(options: IFlexSlashCommandExecutionOptions): IFlexPromptOptions;

package/dist_ts/utils.validation.js

@@ -0,0 +1,158 @@
+import { FlexHarnessValidationError } from './errors.js';
+import { FLEX_PROJECT_MANAGEMENT_LIMITS } from './interfaces.js';
+const maxProjectedErrorNameBytes = 128;
+const maxProjectedErrorMessageBytes = 2048;
+const maxProjectedErrorCodeBytes = 128;
+export function validateIdentifier(value, name) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
+    }
+}
+export function validateUtf8String(value, name, maxBytes, nonEmpty = false) {
+    if (typeof value !== 'string'
+        || (nonEmpty && !value.trim())
+        || Buffer.byteLength(value, 'utf8') > maxBytes) {
+        throw new FlexHarnessValidationError(`${name} must be ${nonEmpty ? 'a non-empty ' : 'a '}string of at most ${maxBytes} UTF-8 bytes.`);
+    }
+}
+export function validateProjectedErrorInfo(value) {
+    if (!value
+        || typeof value !== 'object'
+        || Array.isArray(value)
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        throw new FlexHarnessValidationError('External error projection is invalid.');
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const unsupportedKey = Reflect.ownKeys(descriptors).find((key) => typeof key !== 'string' || !['name', 'message', 'code'].includes(key));
+    const name = descriptors.name?.value;
+    const message = descriptors.message?.value;
+    const code = descriptors.code?.value;
+    if (unsupportedKey
+        || descriptors.name?.get !== undefined
+        || descriptors.name?.set !== undefined
+        || descriptors.message?.get !== undefined
+        || descriptors.message?.set !== undefined
+        || descriptors.code?.get !== undefined
+        || descriptors.code?.set !== undefined
+        || typeof name !== 'string'
+        || !name
+        || Buffer.byteLength(name, 'utf8') > maxProjectedErrorNameBytes
+        || typeof message !== 'string'
+        || !message
+        || Buffer.byteLength(message, 'utf8') > maxProjectedErrorMessageBytes
+        || (code !== undefined
+            && (typeof code !== 'string'
+                || !code
+                || Buffer.byteLength(code, 'utf8') > maxProjectedErrorCodeBytes))) {
+        throw new FlexHarnessValidationError('External error projection is invalid.');
+    }
+    return Object.freeze({ name, message, ...(code === undefined ? {} : { code }) });
+}
+export function validateUpdateSessionOptions(options) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new FlexHarnessValidationError('updateSession options must be a plain object.');
+    }
+    const keys = Object.keys(options);
+    if (keys.length === 0)
+        throw new FlexHarnessValidationError('updateSession requires title or archived.');
+    const unsupportedKey = keys.find((key) => key !== 'title' && key !== 'archived');
+    if (unsupportedKey)
+        throw new FlexHarnessValidationError(`updateSession does not support "${unsupportedKey}".`);
+    if (Object.prototype.hasOwnProperty.call(options, 'title') && options.title !== null) {
+        validateUtf8String(options.title, 'title', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes, true);
+    }
+    if (Object.prototype.hasOwnProperty.call(options, 'archived') && typeof options.archived !== 'boolean') {
+        throw new FlexHarnessValidationError('archived must be a boolean.');
+    }
+}
+export function validateProjectTaskStatus(value) {
+    if (!['pending', 'in_progress', 'completed', 'cancelled'].includes(String(value))) {
+        throw new FlexHarnessValidationError('Project task status is invalid.');
+    }
+}
+export function validateProjectTaskPriority(value) {
+    if (!['high', 'medium', 'low'].includes(String(value))) {
+        throw new FlexHarnessValidationError('Project task priority is invalid.');
+    }
+}
+export function validateProjectTaskId(value) {
+    validateUtf8String(value, 'project task id', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskIdBytes, true);
+}
+export function validateProjectTaskContent(value) {
+    validateUtf8String(value, 'project task content', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskContentBytes, true);
+}
+export function validateCreateProjectTaskInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new FlexHarnessValidationError('Project task create input must be a plain object.');
+    }
+    const unsupported = Object.keys(input)
+        .find((key) => !['id', 'content', 'status', 'priority'].includes(key));
+    if (unsupported) {
+        throw new FlexHarnessValidationError(`Project task create input does not support "${unsupported}".`);
+    }
+    validateProjectTaskId(input.id);
+    validateProjectTaskContent(input.content);
+    if (input.status !== undefined)
+        validateProjectTaskStatus(input.status);
+    if (input.priority !== undefined)
+        validateProjectTaskPriority(input.priority);
+}
+export function validateUpdateProjectTaskInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new FlexHarnessValidationError('Project task update input must be a plain object.');
+    }
+    const keys = Object.keys(input);
+    const unsupported = keys.find((key) => !['id', 'content', 'status', 'priority'].includes(key));
+    if (unsupported) {
+        throw new FlexHarnessValidationError(`Project task update input does not support "${unsupported}".`);
+    }
+    if (!keys.some((key) => key !== 'id')) {
+        throw new FlexHarnessValidationError('Project task update requires a changed field.');
+    }
+    validateProjectTaskId(input.id);
+    if (input.content !== undefined)
+        validateProjectTaskContent(input.content);
+    if (input.status !== undefined)
+        validateProjectTaskStatus(input.status);
+    if (input.priority !== undefined)
+        validateProjectTaskPriority(input.priority);
+}
+export function validatePromptOptions(options, scheduled) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new FlexHarnessValidationError('Prompt options must be a plain object.');
+    }
+    const supported = scheduled
+        ? ['modelHint', 'system', 'maxSteps', 'debounceMs']
+        : ['modelHint', 'system', 'maxSteps'];
+    const unsupported = Object.keys(options).find((key) => !supported.includes(key));
+    if (unsupported)
+        throw new FlexHarnessValidationError(`Prompt options do not support "${unsupported}".`);
+    if (options.modelHint !== undefined)
+        validateIdentifier(options.modelHint, 'modelHint');
+    if (options.system !== undefined)
+        validateIdentifier(options.system, 'system');
+    if (options.maxSteps !== undefined && (!Number.isSafeInteger(options.maxSteps) || options.maxSteps < 1)) {
+        throw new FlexHarnessValidationError('maxSteps must be a positive integer.');
+    }
+}
+export function validateSlashCommandExecutionOptions(options) {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new FlexHarnessValidationError('Slash command execution options must be a plain object.');
+    }
+    const unsupported = Object.keys(options)
+        .find((key) => !['modelHint', 'system', 'maxSteps', 'signal'].includes(key));
+    if (unsupported) {
+        throw new FlexHarnessValidationError(`Slash command execution options do not support "${unsupported}".`);
+    }
+    if (options.signal !== undefined && !(options.signal instanceof AbortSignal)) {
+        throw new FlexHarnessValidationError('Slash command signal must be an AbortSignal.');
+    }
+    const promptOptions = {
+        ...(options.modelHint === undefined ? {} : { modelHint: options.modelHint }),
+        ...(options.system === undefined ? {} : { system: options.system }),
+        ...(options.maxSteps === undefined ? {} : { maxSteps: options.maxSteps }),
+    };
+    validatePromptOptions(promptOptions, false);
+    return promptOptions;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.validation.js","sourceRoot":"","sources":["../ts/utils.validation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/flexharness",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "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",

package/readme.hints.md

@@ -2,6 +2,13 @@
 
 Implementation findings for flexharness.
 
+## Internal module boundaries
+
+- `classes.flexharness.ts` owns stateful coordination: admission, queues, canonical finalization, permissions, reversion, persistence reconciliation, resource cleanup, retirement, and disposal. Stateless boundary policy must not be added back to this class.
+- Constructor policy belongs in `utils.harnessoptions.ts`; reusable public-input checks belong in `utils.validation.ts`; public projection and transfer bounds belong in `utils.transfer.ts`; tool-result normalization belongs in `utils.tooloutput.ts`.
+- Store adapters remain in `classes.stores.ts`, while strict Agent-event and Tool-job codecs belong in `utils.storecodecs.ts`. Store codecs do not own CAS, queue, filesystem, or provider lifecycle behavior.
+- Internal utility modules are implementation details and are not re-exported from `index.ts`. Shared policy such as reserved slash-command names and subagent name bounds has one owner and is imported by every caller.
+
 ## SmartAgent boundary
 
 - SmartAgent is the canonical private conversation and execution runtime. FlexHarness creates one transactional `AgentSession` per public session and derives its public model, prompt, provider-option, tool-set, and result aliases from SmartAgent exports.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '4.1.0',
+  version: '4.1.1',
   description: 'Provider-neutral model-session runtime with durable history, permissions, typed events, and pluggable local or remote tool execution.'
 }