@modelprofile.com/flexharness 8.1.0 → 8.3.0

package/dist_ts/utils.validation.js

@@ -1,3 +1,4 @@
+import * as plugins from './plugins.js';
 import { FlexHarnessValidationError } from './errors.js';
 import { FLEX_PROJECT_MANAGEMENT_LIMITS, FLEX_SESSION_GENERATION_COHORT_MAX_ENTRIES, FLEX_SESSION_GENERATION_ID_MAX_BYTES, } from './interfaces.js';
 const maxProjectedErrorNameBytes = 128;
@@ -87,25 +88,27 @@ export function validateDeleteSessionGenerationCohortInput(value) {
     }
     return { root, authorizedBySessionId };
 }
-export function validateProjectedErrorInfo(value) {
+/** A plain object whose own properties are all string-keyed data properties, so reading them runs no code. */
+function isPlainDataObject(value) {
     if (!value
         || typeof value !== 'object'
         || Array.isArray(value)
-        || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        return false;
+    return Reflect.ownKeys(value).every((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return typeof key === 'string' && descriptor !== undefined && 'value' in descriptor;
+    });
+}
+export function validateProjectedErrorInfo(value) {
+    if (!isPlainDataObject(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;
+    const unsupportedKey = Object.getOwnPropertyNames(value)
+        .find((key) => !['name', 'message', 'code', 'limit'].includes(key));
+    const { name, message, code, limit } = 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
+        || (limit !== undefined && !(isPlainDataObject(limit) && plugins.isModelLimitInfo(limit)))
         || typeof name !== 'string'
         || !name
         || Buffer.byteLength(name, 'utf8') > maxProjectedErrorNameBytes
@@ -118,7 +121,12 @@ export function validateProjectedErrorInfo(value) {
                 || Buffer.byteLength(code, 'utf8') > maxProjectedErrorCodeBytes))) {
         throw new FlexHarnessValidationError('External error projection is invalid.');
     }
-    return Object.freeze({ name, message, ...(code === undefined ? {} : { code }) });
+    return Object.freeze({
+        name,
+        message,
+        ...(code === undefined ? {} : { code }),
+        ...(limit === undefined ? {} : { limit: Object.freeze({ ...limit }) }),
+    });
 }
 export function validateUpdateSessionOptions(options) {
     if (!options || typeof options !== 'object' || Array.isArray(options)) {
@@ -227,4 +235,4 @@ export function validateSlashCommandExecutionOptions(options) {
     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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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.validation.js","sourceRoot":"","sources":["../ts/utils.validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,8BAA8B,EAC9B,0CAA0C,EAC1C,oCAAoC,GACrC,MAAM,iBAAiB,CAAC;AAczB,MAAM,0BAA0B,GAAG,GAAG,CAAC;AACvC,MAAM,6BAA6B,GAAG,IAAI,CAAC;AAC3C,MAAM,0BAA0B,GAAG,GAAG,CAAC;AACvC,MAAM,uBAAuB,GAAG,wBAAwB,CAAC;AAEzD,MAAM,UAAU,kBAAkB,CAAC,KAAa,EAAE,IAAY;IAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,0BAA0B,CAAC,GAAG,IAAI,8BAA8B,CAAC,CAAC;IAC9E,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB,CAChC,KAAc,EACd,IAAY,EACZ,QAAgB,EAChB,QAAQ,GAAG,KAAK;IAEhB,IACE,OAAO,KAAK,KAAK,QAAQ;WACtB,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;WAC3B,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,QAAQ,EAC9C,CAAC;QACD,MAAM,IAAI,0BAA0B,CAClC,GAAG,IAAI,YAAY,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,qBAAqB,QAAQ,eAAe,CAChG,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,2BAA2B,CACzC,KAAc,EACd,IAAI,GAAG,qBAAqB;IAE5B,IACE,OAAO,KAAK,KAAK,QAAQ;WACtB,CAAC,KAAK,CAAC,IAAI,EAAE;WACb,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,oCAAoC;WACvE,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,EACtC,CAAC;QACD,MAAM,IAAI,0BAA0B,CAClC,GAAG,IAAI,qEAAqE,oCAAoC,eAAe,CAChI,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,iCAAiC,CAAC,KAAc,EAAE,IAAY;IACrE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,0BAA0B,CAAC,GAAG,IAAI,8BAA8B,CAAC,CAAC;IAC9E,CAAC;AACH,CAAC;AAED,SAAS,oCAAoC,CAC3C,KAAc,EACd,IAAY;IAEZ,IACE,CAAC,KAAK;WACH,OAAO,KAAK,KAAK,QAAQ;WACzB,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;WACpB,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EACnE,CAAC;QACD,MAAM,IAAI,0BAA0B,CAAC,GAAG,IAAI,0BAA0B,CAAC,CAAC;IAC1E,CAAC;IACD,MAAM,KAAK,GAAG,KAAgC,CAAC;IAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpC,IACE,IAAI,CAAC,MAAM,KAAK,CAAC;WACd,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ;eACxC,CAAC,CAAC,WAAW,EAAE,qBAAqB,EAAE,2BAA2B,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EACtF,CAAC;QACD,MAAM,IAAI,0BAA0B,CAAC,GAAG,IAAI,+CAA+C,CAAC,CAAC;IAC/F,CAAC;IACD,kBAAkB,CAAC,KAAK,CAAC,SAAmB,EAAE,GAAG,IAAI,YAAY,CAAC,CAAC;IACnE,2BAA2B,CAAC,KAAK,CAAC,mBAAmB,EAAE,GAAG,IAAI,sBAAsB,CAAC,CAAC;IACtF,iCAAiC,CAC/B,KAAK,CAAC,yBAAyB,EAC/B,GAAG,IAAI,4BAA4B,CACpC,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,SAAS,EAAE,KAAK,CAAC,SAAmB;QACpC,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;QAC9C,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;KAC3D,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,0CAA0C,CACxD,KAA8C;IAK9C,IACE,CAAC,KAAK;WACH,OAAO,KAAK,KAAK,QAAQ;WACzB,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;WACpB,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,EACnE,CAAC;QACD,MAAM,IAAI,0BAA0B,CAClC,6DAA6D,CAC9D,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpC,IACE,IAAI,CAAC,MAAM,KAAK,CAAC;WACd,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,GAAG,KAAK,QAAQ;eACxC,CAAC,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EACjD,CAAC;QACD,MAAM,IAAI,0BAA0B,CAClC,yFAAyF,CAC1F,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,oCAAoC,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACtE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,0BAA0B,CAAC,oCAAoC,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,0CAA0C,EAAE,CAAC;QAC/E,MAAM,IAAI,0BAA0B,CAClC,4BAA4B,0CAA0C,WAAW,CAClF,CAAC;IACJ,CAAC;IACD,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAGlC,CAAC;IACJ,IAAI,iBAAqC,CAAC;IAC1C,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC;QACjE,MAAM,KAAK,GAAG,oCAAoC,CAChD,QAAQ,EACR,oBAAoB,KAAK,GAAG,CAC7B,CAAC;QACF,IAAI,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/C,MAAM,IAAI,0BAA0B,CAClC,kDAAkD,KAAK,CAAC,SAAS,IAAI,CACtE,CAAC;QACJ,CAAC;QACD,IAAI,iBAAiB,KAAK,SAAS,IAAI,iBAAiB,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YAC5E,MAAM,IAAI,0BAA0B,CAClC,mEAAmE,CACpE,CAAC;QACJ,CAAC;QACD,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClD,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAC;IACtC,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC;AACzC,CAAC;AAED,8GAA8G;AAC9G,SAAS,iBAAiB,CAAC,KAAc;IACvC,IACE,CAAC,KAAK;WACH,OAAO,KAAK,KAAK,QAAQ;WACzB,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;WACpB,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;QAC1C,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC/D,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,UAAU,KAAK,SAAS,IAAI,OAAO,IAAI,UAAU,CAAC;IACtF,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,0BAA0B,CAAC,uCAAuC,CAAC,CAAC;IAChF,CAAC;IACD,MAAM,cAAc,GAAG,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC;SACrD,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACtE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAC7C,IACE,cAAc;WACX,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;WACvF,OAAO,IAAI,KAAK,QAAQ;WACxB,CAAC,IAAI;WACL,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,0BAA0B;WAC5D,OAAO,OAAO,KAAK,QAAQ;WAC3B,CAAC,OAAO;WACR,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,6BAA6B;WAClE,CAAC,IAAI,KAAK,SAAS;eACjB,CAAC,OAAO,IAAI,KAAK,QAAQ;mBACvB,CAAC,IAAI;mBACL,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,0BAA0B,CAAC,CAAC,EACrE,CAAC;QACD,MAAM,IAAI,0BAA0B,CAAC,uCAAuC,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;QACvC,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC;KACvE,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,OAAkC;IAC7E,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,0BAA0B,CAAC,+CAA+C,CAAC,CAAC;IACxF,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,0BAA0B,CAAC,2CAA2C,CAAC,CAAC;IACzG,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,IAAI,GAAG,KAAK,UAAU,CAAC,CAAC;IACjF,IAAI,cAAc;QAAE,MAAM,IAAI,0BAA0B,CAAC,mCAAmC,cAAc,IAAI,CAAC,CAAC;IAChH,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QACrF,kBAAkB,CAChB,OAAO,CAAC,KAAK,EACb,OAAO,EACP,8BAA8B,CAAC,aAAa,EAC5C,IAAI,CACL,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACvG,MAAM,IAAI,0BAA0B,CAAC,6BAA6B,CAAC,CAAC;IACtE,CAAC;AACH,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,KAAc;IACtD,IAAI,CAAC,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAClF,MAAM,IAAI,0BAA0B,CAAC,iCAAiC,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,KAAc;IACxD,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QACvD,MAAM,IAAI,0BAA0B,CAAC,mCAAmC,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,kBAAkB,CAChB,KAAK,EACL,iBAAiB,EACjB,8BAA8B,CAAC,cAAc,EAC7C,IAAI,CACL,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,kBAAkB,CAChB,KAAK,EACL,sBAAsB,EACtB,8BAA8B,CAAC,mBAAmB,EAClD,IAAI,CACL,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,8BAA8B,CAAC,KAAkC;IAC/E,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,MAAM,IAAI,0BAA0B,CAAC,mDAAmD,CAAC,CAAC;IAC5F,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;SACnC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACzE,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,IAAI,0BAA0B,CAAC,+CAA+C,WAAW,IAAI,CAAC,CAAC;IACvG,CAAC;IACD,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAChC,0BAA0B,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC1C,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;QAAE,yBAAyB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACxE,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS;QAAE,2BAA2B,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AAChF,CAAC;AAED,MAAM,UAAU,8BAA8B,CAAC,KAAkC;IAC/E,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,MAAM,IAAI,0BAA0B,CAAC,mDAAmD,CAAC,CAAC;IAC5F,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChC,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/F,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,IAAI,0BAA0B,CAAC,+CAA+C,WAAW,IAAI,CAAC,CAAC;IACvG,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,0BAA0B,CAAC,+CAA+C,CAAC,CAAC;IACxF,CAAC;IACD,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAChC,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;QAAE,0BAA0B,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3E,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;QAAE,yBAAyB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACxE,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS;QAAE,2BAA2B,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AAChF,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,OAA2B,EAAE,SAAkB;IACnF,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,0BAA0B,CAAC,wCAAwC,CAAC,CAAC;IACjF,CAAC;IACD,MAAM,SAAS,GAAG,SAAS;QACzB,CAAC,CAAC,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,YAAY,CAAC;QACnD,CAAC,CAAC,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IACxC,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACjF,IAAI,WAAW;QAAE,MAAM,IAAI,0BAA0B,CAAC,kCAAkC,WAAW,IAAI,CAAC,CAAC;IACzG,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS;QAAE,kBAAkB,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACxF,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS;QAAE,kBAAkB,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC/E,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC;QACxG,MAAM,IAAI,0BAA0B,CAAC,sCAAsC,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC;AAED,MAAM,UAAU,oCAAoC,CAClD,OAA0C;IAE1C,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,0BAA0B,CAAC,yDAAyD,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;SACrC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/E,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,IAAI,0BAA0B,CAClC,mDAAmD,WAAW,IAAI,CACnE,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,YAAY,WAAW,CAAC,EAAE,CAAC;QAC7E,MAAM,IAAI,0BAA0B,CAAC,8CAA8C,CAAC,CAAC;IACvF,CAAC;IACD,MAAM,aAAa,GAAuB;QACxC,GAAG,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;QAC5E,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QACnE,GAAG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC;KAC1E,CAAC;IACF,qBAAqB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAC5C,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/dist_ts_document/index.d.ts

@@ -1,19 +1,66 @@
 import type { ModelMessage } from 'ai';
-import type { TSmartAiLanguageModel } from '@modelprofile.com/flexharness-models';
-export interface IDocumentOptions {
+import type { TSmartAiLanguageModel, TSmartAiProviderOptions } from '@modelprofile.com/flexharness-models';
+/** Options every document request accepts in addition to its model and messages. */
+export interface IDocumentRequestOptions {
+    /** Passed to the model call unchanged, for example `{ openai: { store: false } }`. */
+    providerOptions?: TSmartAiProviderOptions;
+    /**
+     * Checked before each document is rendered and before the model call, and passed to the model
+     * call. SmartPDF cannot stop a document it is rendering, so that render finishes first.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * The most rendered pages one request may send to the model. A request with more pages rejects
+     * with `DocumentPageLimitError` before the model is called; documents after the one that
+     * exceeded the limit are not rendered.
+     */
+    maxPages?: number;
+}
+export interface IDocumentOptions extends IDocumentRequestOptions {
     model: TSmartAiLanguageModel;
     systemMessage?: string;
     userMessage: string;
     pdfDocuments: Uint8Array[];
     messageHistory?: ModelMessage[];
 }
-export interface IPdfTextExtractionOptions {
+export interface IPdfTextExtractionOptions extends IDocumentRequestOptions {
     model: TSmartAiLanguageModel;
     systemMessage?: string;
     userMessage?: string;
     messageHistory?: ModelMessage[];
 }
+/** Token usage of a document request, summed over its model steps; usage a provider leaves out counts as zero. */
+export interface IDocumentUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export interface IDocumentAnalysisResult {
+    text: string;
+    usage: IDocumentUsage;
+    /** Rendered pages sent to the model. A page that renders to an empty image is not sent. */
+    pageCount: number;
+}
+export interface IDocumentPageLimitErrorDetails {
+    renderedPages: number;
+    maxPages: number;
+    documentCount: number;
+    allDocumentsRendered: boolean;
+}
+/** A request whose documents render to more pages than its `maxPages`; the model was not called. */
+export declare class DocumentPageLimitError extends Error {
+    /** Pages rendered before the request stopped; with several documents, later documents are not counted. */
+    readonly renderedPages: number;
+    readonly maxPages: number;
+    constructor(details: IDocumentPageLimitErrorDetails);
+}
 /** The model-based PDF OCR recipe formerly provided by SmartOCR. */
 export declare function extractTextFromPdf(pdfDocument: Uint8Array, options: IPdfTextExtractionOptions): Promise<string>;
+/** `extractTextFromPdf` that also returns the request's token usage and the pages sent. */
+export declare function extractTextFromPdfWithUsage(pdfDocument: Uint8Array, options: IPdfTextExtractionOptions): Promise<IDocumentAnalysisResult>;
 export declare function analyzeDocuments(options: IDocumentOptions): Promise<string>;
+/** `analyzeDocuments` that also returns the request's token usage and the pages sent. */
+export declare function analyzeDocumentsWithUsage(options: IDocumentOptions): Promise<IDocumentAnalysisResult>;
 export declare function stopSmartpdf(): Promise<void>;

package/dist_ts_document/index.js

@@ -1,28 +1,81 @@
 import * as plugins from './plugins.js';
-let smartpdfInstance = null;
-async function ensureSmartpdf() {
-    if (!smartpdfInstance) {
-        smartpdfInstance = new plugins.smartpdf.SmartPdf();
-        await smartpdfInstance.start();
+/** The one start of the shared SmartPDF instance; every request awaits it, and a failed start is forgotten. */
+let smartpdfStart = null;
+function ensureSmartpdf() {
+    if (!smartpdfStart) {
+        const instance = new plugins.smartpdf.SmartPdf();
+        const start = instance.start().then(() => instance);
+        smartpdfStart = start;
+        start.catch(() => {
+            if (smartpdfStart === start) {
+                smartpdfStart = null;
+            }
+        });
     }
-    return smartpdfInstance;
+    return smartpdfStart;
 }
+/** A request whose documents render to more pages than its `maxPages`; the model was not called. */
+export class DocumentPageLimitError extends Error {
+    /** Pages rendered before the request stopped; with several documents, later documents are not counted. */
+    renderedPages;
+    maxPages;
+    constructor(details) {
+        const subject = details.documentCount === 1
+            ? `The document has ${details.renderedPages} pages`
+            : details.allDocumentsRendered
+                ? `The documents have ${details.renderedPages} pages`
+                : `The documents have at least ${details.renderedPages} pages`;
+        super(`${subject}, more than the ${details.maxPages} allowed.`);
+        this.name = 'DocumentPageLimitError';
+        this.renderedPages = details.renderedPages;
+        this.maxPages = details.maxPages;
+    }
+}
+const DEFAULT_OCR_SYSTEM_MESSAGE = 'You are a precise OCR engine. Extract text faithfully and do not summarize.';
+const DEFAULT_OCR_USER_MESSAGE = 'Extract all readable text from this PDF. Preserve page order, line breaks, table structure, and obvious headings. Return only the extracted text.';
 /** The model-based PDF OCR recipe formerly provided by SmartOCR. */
 export async function extractTextFromPdf(pdfDocument, options) {
-    return analyzeDocuments({
+    return (await extractTextFromPdfWithUsage(pdfDocument, options)).text;
+}
+/** `extractTextFromPdf` that also returns the request's token usage and the pages sent. */
+export async function extractTextFromPdfWithUsage(pdfDocument, options) {
+    return analyzeDocumentsWithUsage({
         model: options.model,
-        systemMessage: options.systemMessage ?? 'You are a precise OCR engine. Extract text faithfully and do not summarize.',
-        userMessage: options.userMessage ?? 'Extract all readable text from this PDF. Preserve page order, line breaks, table structure, and obvious headings. Return only the extracted text.',
+        systemMessage: options.systemMessage ?? DEFAULT_OCR_SYSTEM_MESSAGE,
+        userMessage: options.userMessage ?? DEFAULT_OCR_USER_MESSAGE,
         pdfDocuments: [pdfDocument],
         messageHistory: options.messageHistory,
+        providerOptions: options.providerOptions,
+        abortSignal: options.abortSignal,
+        maxPages: options.maxPages,
     });
 }
 export async function analyzeDocuments(options) {
-    const pdf = await ensureSmartpdf();
+    return (await analyzeDocumentsWithUsage(options)).text;
+}
+/** `analyzeDocuments` that also returns the request's token usage and the pages sent. */
+export async function analyzeDocumentsWithUsage(options) {
+    const maxPages = options.maxPages;
+    if (maxPages !== undefined && (!Number.isSafeInteger(maxPages) || maxPages < 1)) {
+        throw new RangeError('maxPages must be a positive whole number.');
+    }
+    const abortSignal = options.abortSignal;
+    abortSignal?.throwIfAborted();
     const imagePages = [];
-    for (const doc of options.pdfDocuments) {
+    for (const [index, doc] of options.pdfDocuments.entries()) {
+        const pdf = await ensureSmartpdf();
+        abortSignal?.throwIfAborted();
         const pages = await pdf.convertPDFToPngBytes(doc);
+        abortSignal?.throwIfAborted();
         imagePages.push(...pages);
+        if (maxPages !== undefined && imagePages.length > maxPages) {
+            throw new DocumentPageLimitError({
+                renderedPages: imagePages.length,
+                maxPages,
+                documentCount: options.pdfDocuments.length,
+                allDocumentsRendered: index === options.pdfDocuments.length - 1,
+            });
+        }
     }
     // Filter out empty buffers
     const validPages = imagePages.filter(page => page && page.length > 0);
@@ -43,13 +96,40 @@ export async function analyzeDocuments(options) {
                 ],
             },
         ],
+        providerOptions: options.providerOptions,
+        abortSignal,
     });
-    return result.text;
+    const usage = result.totalUsage;
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    return {
+        text: result.text,
+        usage: {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            cacheReadTokens: usage.inputTokenDetails.cacheReadTokens ?? 0,
+            cacheWriteTokens: usage.inputTokenDetails.cacheWriteTokens ?? 0,
+        },
+        pageCount: validPages.length,
+    };
 }
 export async function stopSmartpdf() {
-    if (smartpdfInstance) {
-        await smartpdfInstance.stop();
-        smartpdfInstance = null;
+    const start = smartpdfStart;
+    if (!start) {
+        return;
+    }
+    // forget the instance before waiting on anything, so a request made from now on starts a fresh one
+    // instead of receiving the instance that is being stopped
+    smartpdfStart = null;
+    let instance;
+    try {
+        instance = await start;
+    }
+    catch {
+        // a failed start left no started instance that could be stopped
+        return;
     }
+    await instance.stop();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -62,8 +62,8 @@
     }
   },
   "dependencies": {
-    "@modelprofile.com/flexharness-agent": "8.1.0",
-    "@modelprofile.com/flexharness-models": "8.1.0",
+    "@modelprofile.com/flexharness-agent": "8.3.0",
+    "@modelprofile.com/flexharness-models": "8.3.0",
     "@push.rocks/smartrequest": "^5.0.1",
     "ai": "^7.0.79",
     "zod": "^4.4.1"

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '8.1.0',
+  version: '8.3.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }

package/ts/classes.flexharness.ts

@@ -16,6 +16,7 @@ import {
   FlexHarnessStoreCommitUncertainError,
   FlexHarnessValidationError,
   errorToInfo,
+  modelLimitErrorInfo,
 } from './errors.js';
 import {
   FLEX_PROJECT_MANAGEMENT_LIMITS,
@@ -79,6 +80,7 @@ import type {
   IFlexSchedulePromptOptions,
   IFlexScopeSnapshot,
   IFlexSession,
+  IFlexSessionActivity,
   IFlexSessionGeneration,
   IFlexSessionGenerationCohortEntry,
   IFlexSessionReversionGroup,
@@ -658,6 +660,14 @@ function combineErrors(errors: unknown[]): unknown {
   return Object.freeze(combined);
 }
 
+/** The error and model limit a finished run leaves on its session activity. */
+function terminalActivityError(message: IFlexMessage): Pick<IFlexSessionActivity, 'error' | 'limit'> {
+  return {
+    ...(message.error ? { error: message.error } : {}),
+    ...(message.limit ? { limit: message.limit } : {}),
+  };
+}
+
 function isAbortError(error: unknown): boolean {
   return error instanceof FlexHarnessAbortError
     || (error instanceof DOMException && error.name === 'AbortError')
@@ -5677,8 +5687,11 @@ export class FlexHarness<TScope = unknown> {
       assistantMessage.usage = cloneSerializable(result.usage);
     } else {
       const message = truncateUtf8(error?.message ?? externalErrorFallback.message, maxTransferMetadataBytes);
-      userMessage.error = message;
-      assistantMessage.error = message;
+      const limit = error instanceof FlexHarnessExternalError ? error.limit : undefined;
+      for (const failedMessage of [userMessage, assistantMessage]) {
+        failedMessage.error = message;
+        if (limit) failedMessage.limit = cloneSerializable(limit);
+      }
     }
     return {
       runId: run.runId,
@@ -6766,7 +6779,7 @@ export class FlexHarness<TScope = unknown> {
         status: activityStatus,
         startedAt: run.stored.session.activity.startedAt,
         completedAt: timestamp,
-        ...(terminal.assistantMessage.error ? { error: terminal.assistantMessage.error } : {}),
+        ...terminalActivityError(terminal.assistantMessage),
       };
       run.stored.session.updatedAt = timestamp;
     }, true);
@@ -7025,6 +7038,19 @@ export class FlexHarness<TScope = unknown> {
     }
   }
 
+  private onRetry(state: IStorageState, sessionId: string, retry: plugins.IAgentRetryEvent): void {
+    const run = this.callbackRun(state, sessionId);
+    if (!run || !this.reserveCallbackCapacity(run, 1, 0, 0)) return;
+    this.emitEvent(run.scopeId, run.stored.session, {
+      type: 'run.retrying',
+      runId: run.runId,
+      attempt: retry.attempt,
+      maxAttempts: retry.maxAttempts,
+      delayMs: retry.delayMs,
+      reason: retry.reason,
+    });
+  }
+
   private callbackRun(state: IStorageState, sessionId: string): IActiveRun | undefined {
     const run = state.activeRuns.get(sessionId);
     return !run || run.callbacksClosed || run.callbackError ? undefined : run;
@@ -7777,7 +7803,8 @@ export class FlexHarness<TScope = unknown> {
     if ((typeof error === 'object' && error !== null) && this.trustedInternalErrors.has(error)) {
       return error as Error;
     }
-    let info = externalErrorFallback;
+    const defaultInfo = modelLimitErrorInfo(error) ?? externalErrorFallback;
+    let info = defaultInfo;
     if (this.externalErrorProjector) {
       try {
         info = validateProjectedErrorInfo(this.externalErrorProjector(error, {
@@ -7787,7 +7814,7 @@ export class FlexHarness<TScope = unknown> {
           runId,
         }));
       } catch {
-        info = externalErrorFallback;
+        info = defaultInfo;
       }
     }
     return this.trustInternalError(new FlexHarnessExternalError(info));
@@ -8233,6 +8260,7 @@ export class FlexHarness<TScope = unknown> {
         onToolCallStart: (event) => this.onToolStart(state, sessionId, event),
         onToolCallUpdate: (event) => this.onToolUpdate(state, sessionId, event),
         onToolCallFinish: (event) => this.onToolFinish(state, sessionId, event),
+        onRetry: (event) => this.onRetry(state, sessionId, event),
       };
       stored.agentSession = await this.withCompactorContext(
         compactorContext,
@@ -8405,9 +8433,7 @@ export class FlexHarness<TScope = unknown> {
         runId: latestTerminal.runId,
         status: latestTerminal.status === 'completed' ? 'idle' : latestTerminal.status,
         completedAt,
-        ...(latestTerminal.assistantMessage.error
-          ? { error: latestTerminal.assistantMessage.error }
-          : {}),
+        ...terminalActivityError(latestTerminal.assistantMessage),
       };
       stored.session.updatedAt = completedAt;
     } else if (['scheduled', 'running', 'waiting_permission'].includes(stored.session.status)) {

package/ts/errors.ts

@@ -1,4 +1,10 @@
-import type { IFlexErrorInfo } from './interfaces.js';
+import * as plugins from './plugins.js';
+import type { IFlexErrorInfo, TFlexModelLimit } from './interfaces.js';
+
+const modelLimitErrorCodes: Record<TFlexModelLimit['kind'], string> = {
+  usage_limit: 'FLEX_USAGE_LIMIT',
+  rate_limit: 'FLEX_RATE_LIMIT',
+};
 
 export class FlexHarnessError extends Error {
   public readonly code: string;
@@ -85,9 +91,12 @@ export class FlexHarnessCallbackOverflowError extends FlexHarnessError {
 }
 
 export class FlexHarnessExternalError extends FlexHarnessError {
+  public readonly limit: TFlexModelLimit | undefined;
+
   constructor(info: IFlexErrorInfo) {
     super(info.code ?? 'FLEX_EXTERNAL_ERROR', info.message);
     this.name = info.name;
+    this.limit = info.limit;
   }
 }
 
@@ -164,6 +173,7 @@ export function errorToInfo(error: unknown): IFlexErrorInfo {
       name: error.name,
       message: error.message,
       code: error.code,
+      ...(error instanceof FlexHarnessExternalError && error.limit ? { limit: error.limit } : {}),
     };
   }
   if (error instanceof Error) {
@@ -179,6 +189,17 @@ export function errorToInfo(error: unknown): IFlexErrorInfo {
   };
 }
 
+/** The public projection of a model limit error, which names the limit and its reset time. */
+export function modelLimitErrorInfo(error: unknown): IFlexErrorInfo | undefined {
+  if (!plugins.isModelLimitError(error)) return undefined;
+  return {
+    name: 'FlexHarnessExternalError',
+    message: error.message,
+    code: modelLimitErrorCodes[error.limit.kind],
+    limit: error.limit,
+  };
+}
+
 export function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }

package/ts/interfaces.ts

@@ -22,6 +22,9 @@ export type TFlexAgentToolCallUpdateEvent = Parameters<
 export type TFlexAgentToolCallFinishEvent = Parameters<
   NonNullable<TFlexAgentSessionOptions['onToolCallFinish']>
 >[0];
+/** A usage or rate limit a model provider reported; `resetsAt` is in epoch milliseconds. */
+export type TFlexModelLimit = plugins.IModelLimitInfo;
+export type TFlexRetryReason = plugins.TAgentRetryReason;
 
 export interface IFlexTextPromptPart {
   type: 'text';
@@ -125,6 +128,8 @@ export interface IFlexMessage {
   model?: IFlexModelIdentity;
   usage?: IFlexUsage;
   error?: string;
+  /** The model limit that failed this run, next to its error. */
+  limit?: TFlexModelLimit;
 }
 
 export interface IFlexSessionActivity {
@@ -133,6 +138,8 @@ export interface IFlexSessionActivity {
   startedAt?: string;
   completedAt?: string;
   error?: string;
+  /** The model limit that failed the last run, next to its error. */
+  limit?: TFlexModelLimit;
 }
 
 export interface IFlexSession {
@@ -1227,6 +1234,16 @@ export interface IFlexRunFinishedEvent extends IFlexEventBase {
   readonly error?: IFlexErrorInfo;
 }
 
+/** The run waits `delayMs` before retrying a rate-limited or unavailable model call. */
+export interface IFlexRunRetryingEvent extends IFlexEventBase {
+  readonly type: 'run.retrying';
+  readonly runId: string;
+  readonly attempt: number;
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly reason: TFlexRetryReason;
+}
+
 export interface IFlexPromptQueueEvent extends IFlexEventBase {
   readonly type: 'prompt.queued' | 'prompt.started' | 'prompt.running' | 'prompt.finished';
   readonly queueId: string;
@@ -1244,6 +1261,8 @@ export interface IFlexErrorInfo {
   name: string;
   message: string;
   code?: string;
+  /** Set when a model usage or rate limit caused the error. */
+  limit?: TFlexModelLimit;
 }
 
 export type TFlexHarnessEvent =
@@ -1256,6 +1275,7 @@ export type TFlexHarnessEvent =
   | IFlexPermissionRequestedEvent
   | IFlexPermissionResolvedEvent
   | IFlexRunFinishedEvent
+  | IFlexRunRetryingEvent
   | IFlexPromptQueueEvent
   | IFlexSessionHistoryChangedEvent;
 

package/ts/plugins.ts

@@ -44,6 +44,7 @@ export type {
   IAgentGenerateResult,
   IAgentGenerationHandle,
   IAgentGenerationLease,
+  IAgentRetryEvent,
   IAgentRunResult,
   IAgentSession,
   IAgentSessionOptions,
@@ -62,6 +63,12 @@ export type {
   TAgentContextCompactor,
   TAgentEvent,
   TAgentGenerationOutcome,
+  TAgentRetryReason,
   TAgentToolCallFinishEvent,
   TAgentToolExecutionReconciliationOptions,
 } from '@modelprofile.com/flexharness-agent';
+
+import { isModelLimitError, isModelLimitInfo } from '@modelprofile.com/flexharness-models';
+
+export { isModelLimitError, isModelLimitInfo };
+export type { IModelLimitInfo } from '@modelprofile.com/flexharness-models';