@modelprofile.com/flexharness-models 8.1.0 → 8.3.0

package/dist_ts_models/index.d.ts

@@ -1,5 +1,6 @@
 export * from './interfaces.js';
 export * from './classes.modelregistry.js';
 export * from './smartai.cache.js';
+export * from './smartai.limits.js';
 export { generateText, streamText, tool, jsonSchema } from 'ai';
 export type { ModelMessage, ToolSet, StreamTextResult } from 'ai';

package/dist_ts_models/index.js

@@ -1,5 +1,6 @@
 export * from './interfaces.js';
 export * from './classes.modelregistry.js';
 export * from './smartai.cache.js';
+export * from './smartai.limits.js';
 export { generateText, streamText, tool, jsonSchema } from 'ai';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxNQUFNLElBQUksQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLE1BQU0sSUFBSSxDQUFDIn0=

package/dist_ts_models/smartai.limits.d.ts

@@ -0,0 +1,68 @@
+import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
+/**
+ * `usage_limit`: the account's quota is spent until it resets, so no retry can succeed earlier.
+ * `rate_limit`: a short throttle that a retry after the advertised delay may pass.
+ */
+export type TModelLimitKind = 'usage_limit' | 'rate_limit';
+export interface IModelLimitInfo {
+    kind: TModelLimitKind;
+    /** The provider that reported the limit, for example `openai` or `anthropic`. */
+    provider: string;
+    /** When the limit resets, in epoch milliseconds. */
+    resetsAt?: number;
+    /** The delay the provider asked for before the next request, in milliseconds. */
+    retryAfterMs?: number;
+    /** The account plan the provider reported. */
+    planType?: string;
+    /** The exhausted limit window, for example `5h` or `7d`. */
+    window?: string;
+}
+/** What a provider dialect reads from a failure; the limit middleware adds the provider. */
+export type TModelLimitClassification = Omit<IModelLimitInfo, 'provider'>;
+/** A failed model call reduced to the parts a limit dialect reads. */
+export interface IModelCallFailure {
+    /** When the failure was observed, in epoch milliseconds; relative reset times count from here. */
+    observedAt: number;
+    /** HTTP status of the failed response, when the provider reported one. */
+    statusCode?: number;
+    /** Response headers with lower-case names. */
+    headers: Readonly<Record<string, string>>;
+    /** The parsed JSON error body, or the error frame of a failed stream. */
+    body?: unknown;
+}
+/** Reads one provider's limit dialect; returns undefined for failures that are not limits. */
+export type TModelLimitClassifier = (failure: IModelCallFailure) => TModelLimitClassification | undefined;
+export interface IModelLimitMiddlewareOptions {
+    provider: string;
+    classify: TModelLimitClassifier;
+}
+/** Upper bound for the provider, plan and window names a limit carries. */
+export declare const MODEL_LIMIT_TEXT_MAX_LENGTH = 128;
+/** The value as a JSON object, or undefined for arrays, primitives and null. */
+export declare function readJsonRecord(value: unknown): Readonly<Record<string, unknown>> | undefined;
+/** Whether a value is a complete, bounded limit description. */
+export declare function isModelLimitInfo(value: unknown): value is IModelLimitInfo;
+/** A short sentence naming the limit and, when known, its reset time. */
+export declare function describeModelLimit(limit: IModelLimitInfo): string;
+/** A provider refused a model call because a usage or rate limit was reached. */
+export declare class ModelLimitError extends Error {
+    readonly limit: Readonly<IModelLimitInfo>;
+    constructor(limit: IModelLimitInfo, options?: ErrorOptions);
+}
+/** Recognizes a ModelLimitError, also one created by another copy of this package. */
+export declare function isModelLimitError(error: unknown): error is ModelLimitError;
+/** Reads `retry-after-ms`, then `retry-after` in seconds or as an HTTP date, from lower-case headers. */
+export declare function readRetryAfterMs(headers: Readonly<Record<string, string>> | undefined, now?: number): number | undefined;
+/** Converts a Unix timestamp in seconds, as a number or numeric string, to epoch milliseconds. */
+export declare function readEpochSeconds(value: unknown): number | undefined;
+/**
+ * A limit from provider-reported values, which are untrusted: a delay or reset time outside the
+ * representable range and an overlong plan or window name are dropped, and a missing reset time
+ * follows from the delay. Kind and provider are kept as given.
+ */
+export declare function createModelLimitInfo(reported: IModelLimitInfo, observedAt: number): IModelLimitInfo;
+/**
+ * Turns the failures a provider dialect recognizes as limits into ModelLimitError, keeping the
+ * original failure as its cause. Covers thrown call errors and error parts of a running stream.
+ */
+export declare function createModelLimitMiddleware(options: IModelLimitMiddlewareOptions): LanguageModelV4Middleware;

package/dist_ts_models/smartai.limits.js

@@ -0,0 +1,185 @@
+import { APICallError } from '@ai-sdk/provider';
+/** Upper bound for the provider, plan and window names a limit carries. */
+export const MODEL_LIMIT_TEXT_MAX_LENGTH = 128;
+/** The latest instant a Date can represent, in epoch milliseconds. */
+const MAX_DATE_EPOCH_MS = 8_640_000_000_000_000;
+const modelLimitKinds = ['usage_limit', 'rate_limit'];
+const modelLimitKeys = new Set([
+    'kind',
+    'provider',
+    'resetsAt',
+    'retryAfterMs',
+    'planType',
+    'window',
+]);
+const modelLimitLabels = {
+    usage_limit: 'Usage limit',
+    rate_limit: 'Rate limit',
+};
+const modelLimitErrorMarker = Symbol.for('@modelprofile.com/flexharness-models/ModelLimitError');
+/** The value as a JSON object, or undefined for arrays, primitives and null. */
+export function readJsonRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isLimitText(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= MODEL_LIMIT_TEXT_MAX_LENGTH;
+}
+function isLimitDelay(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function isLimitInstant(value) {
+    return isLimitDelay(value) && value <= MAX_DATE_EPOCH_MS;
+}
+/** Whether a value is a complete, bounded limit description. */
+export function isModelLimitInfo(value) {
+    const limit = readJsonRecord(value);
+    if (!limit || Object.keys(limit).some((key) => !modelLimitKeys.has(key)))
+        return false;
+    return modelLimitKinds.includes(limit.kind)
+        && isLimitText(limit.provider)
+        && (limit.resetsAt === undefined || isLimitInstant(limit.resetsAt))
+        && (limit.retryAfterMs === undefined || isLimitDelay(limit.retryAfterMs))
+        && (limit.planType === undefined || isLimitText(limit.planType))
+        && (limit.window === undefined || isLimitText(limit.window));
+}
+/** A short sentence naming the limit and, when known, its reset time. */
+export function describeModelLimit(limit) {
+    const label = modelLimitLabels[limit.kind];
+    return limit.resetsAt === undefined
+        ? `${label} reached.`
+        : `${label} reached; resets at ${new Date(limit.resetsAt).toISOString()}.`;
+}
+/** A provider refused a model call because a usage or rate limit was reached. */
+export class ModelLimitError extends Error {
+    limit;
+    constructor(limit, options) {
+        if (!isModelLimitInfo(limit))
+            throw new TypeError('ModelLimitError requires a valid limit description.');
+        super(describeModelLimit(limit), options);
+        this.name = 'ModelLimitError';
+        this.limit = Object.freeze({ ...limit });
+        Object.defineProperty(this, modelLimitErrorMarker, { value: true });
+    }
+}
+/** Recognizes a ModelLimitError, also one created by another copy of this package. */
+export function isModelLimitError(error) {
+    return error instanceof Error
+        && error[modelLimitErrorMarker] === true;
+}
+/** Reads `retry-after-ms`, then `retry-after` in seconds or as an HTTP date, from lower-case headers. */
+export function readRetryAfterMs(headers, now = Date.now()) {
+    const milliseconds = Number.parseFloat(headers?.['retry-after-ms'] ?? '');
+    if (Number.isFinite(milliseconds) && milliseconds >= 0)
+        return Math.ceil(milliseconds);
+    const retryAfter = headers?.['retry-after'];
+    if (retryAfter === undefined)
+        return undefined;
+    const seconds = Number.parseFloat(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.ceil(seconds * 1000);
+    const delay = Date.parse(retryAfter) - now;
+    return Number.isFinite(delay) && delay > 0 ? Math.ceil(delay) : undefined;
+}
+/** Converts a Unix timestamp in seconds, as a number or numeric string, to epoch milliseconds. */
+export function readEpochSeconds(value) {
+    const seconds = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    return typeof seconds === 'number' && Number.isFinite(seconds) && seconds >= 0
+        ? Math.round(seconds * 1000)
+        : undefined;
+}
+function lowerCaseHeaders(headers) {
+    const normalized = {};
+    for (const [name, value] of Object.entries(headers ?? {})) {
+        if (typeof value === 'string')
+            normalized[name.toLowerCase()] = value;
+    }
+    return normalized;
+}
+function parseJsonBody(body) {
+    if (body === undefined)
+        return undefined;
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return body;
+    }
+}
+/**
+ * A limit from provider-reported values, which are untrusted: a delay or reset time outside the
+ * representable range and an overlong plan or window name are dropped, and a missing reset time
+ * follows from the delay. Kind and provider are kept as given.
+ */
+export function createModelLimitInfo(reported, observedAt) {
+    const retryAfterMs = isLimitDelay(reported.retryAfterMs) ? reported.retryAfterMs : undefined;
+    const resetsAt = [reported.resetsAt, retryAfterMs === undefined ? undefined : observedAt + retryAfterMs]
+        .find(isLimitInstant);
+    return {
+        kind: reported.kind,
+        provider: reported.provider,
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+        ...(isLimitText(reported.planType) ? { planType: reported.planType } : {}),
+        ...(isLimitText(reported.window) ? { window: reported.window } : {}),
+    };
+}
+function describeFailure(error, streamHeaders, observedAt) {
+    if (APICallError.isInstance(error)) {
+        return {
+            observedAt,
+            ...(error.statusCode === undefined ? {} : { statusCode: error.statusCode }),
+            headers: lowerCaseHeaders(error.responseHeaders),
+            body: parseJsonBody(error.responseBody) ?? error.data,
+        };
+    }
+    return { observedAt, headers: lowerCaseHeaders(streamHeaders), body: error };
+}
+function completeLimit(provider, classification, failure) {
+    return createModelLimitInfo({
+        ...classification,
+        provider,
+        retryAfterMs: classification.retryAfterMs ?? readRetryAfterMs(failure.headers, failure.observedAt),
+    }, failure.observedAt);
+}
+/**
+ * Turns the failures a provider dialect recognizes as limits into ModelLimitError, keeping the
+ * original failure as its cause. Covers thrown call errors and error parts of a running stream.
+ */
+export function createModelLimitMiddleware(options) {
+    const classifyError = (error, streamHeaders) => {
+        if (isModelLimitError(error))
+            return error;
+        const failure = describeFailure(error, streamHeaders, Date.now());
+        const classification = options.classify(failure);
+        return classification === undefined
+            ? error
+            : new ModelLimitError(completeLimit(options.provider, classification, failure), { cause: error });
+    };
+    const call = async (operation) => {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            throw classifyError(error);
+        }
+    };
+    return {
+        specificationVersion: 'v4',
+        wrapGenerate: ({ doGenerate }) => call(doGenerate),
+        wrapStream: async ({ doStream }) => {
+            const result = await call(doStream);
+            const headers = result.response?.headers;
+            return {
+                ...result,
+                stream: result.stream.pipeThrough(new TransformStream({
+                    transform: (part, controller) => {
+                        controller.enqueue(part.type === 'error' ? { ...part, error: classifyError(part.error, headers) } : part);
+                    },
+                })),
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.limits.js","sourceRoot":"","sources":["../ts_models/smartai.limits.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness-models",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "type": "module",
   "description": "Provider-independent model contracts, prompt caching and explicit model registration.",
   "main": "./dist_ts_models/index.js",

package/readme.md

@@ -15,6 +15,15 @@ pnpm add @modelprofile.com/flexharness-models
 See the [toolbox usage and migration guide](https://code.foss.global/modelprofile.com/flexharness#readme)
 for composition examples and the SmartAI/SmartAgent migration map.
 
+`ModelLimitError` is the one typed error for provider usage and rate limits; its `limit`
+(`IModelLimitInfo`) carries `kind`, `provider`, and when known `resetsAt` (epoch milliseconds),
+`retryAfterMs`, `planType` and `window`. `createModelLimitMiddleware({ provider, classify })`
+raises it for the failures a provider dialect recognizes, from thrown calls and from stream error
+parts, keeping the provider failure as `cause`. A classifier receives the failure's `observedAt` time for relative
+reset delays; a delay or reset time outside the range a `Date` can represent is dropped from the
+limit. `createModelLimitInfo`, `isModelLimitError`, `isModelLimitInfo`, `describeModelLimit`,
+`readRetryAfterMs`, `readEpochSeconds` and `readJsonRecord` are exported for dialects and hosts.
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.

package/ts_models/index.ts

@@ -1,5 +1,6 @@
 export * from './interfaces.js';
 export * from './classes.modelregistry.js';
 export * from './smartai.cache.js';
+export * from './smartai.limits.js';
 export { generateText, streamText, tool, jsonSchema } from 'ai';
 export type { ModelMessage, ToolSet, StreamTextResult } from 'ai';

package/ts_models/readme.md

@@ -15,6 +15,15 @@ pnpm add @modelprofile.com/flexharness-models
 See the [toolbox usage and migration guide](https://code.foss.global/modelprofile.com/flexharness#readme)
 for composition examples and the SmartAI/SmartAgent migration map.
 
+`ModelLimitError` is the one typed error for provider usage and rate limits; its `limit`
+(`IModelLimitInfo`) carries `kind`, `provider`, and when known `resetsAt` (epoch milliseconds),
+`retryAfterMs`, `planType` and `window`. `createModelLimitMiddleware({ provider, classify })`
+raises it for the failures a provider dialect recognizes, from thrown calls and from stream error
+parts, keeping the provider failure as `cause`. A classifier receives the failure's `observedAt` time for relative
+reset delays; a delay or reset time outside the range a `Date` can represent is dropped from the
+limit. `createModelLimitInfo`, `isModelLimitError`, `isModelLimitInfo`, `describeModelLimit`,
+`readRetryAfterMs`, `readEpochSeconds` and `readJsonRecord` are exported for dialects and hosts.
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.

package/ts_models/smartai.limits.ts

@@ -0,0 +1,253 @@
+import { APICallError } from '@ai-sdk/provider';
+import type {
+  LanguageModelV4Middleware,
+  LanguageModelV4StreamPart,
+  SharedV4Headers,
+} from '@ai-sdk/provider';
+
+/**
+ * `usage_limit`: the account's quota is spent until it resets, so no retry can succeed earlier.
+ * `rate_limit`: a short throttle that a retry after the advertised delay may pass.
+ */
+export type TModelLimitKind = 'usage_limit' | 'rate_limit';
+
+export interface IModelLimitInfo {
+  kind: TModelLimitKind;
+  /** The provider that reported the limit, for example `openai` or `anthropic`. */
+  provider: string;
+  /** When the limit resets, in epoch milliseconds. */
+  resetsAt?: number;
+  /** The delay the provider asked for before the next request, in milliseconds. */
+  retryAfterMs?: number;
+  /** The account plan the provider reported. */
+  planType?: string;
+  /** The exhausted limit window, for example `5h` or `7d`. */
+  window?: string;
+}
+
+/** What a provider dialect reads from a failure; the limit middleware adds the provider. */
+export type TModelLimitClassification = Omit<IModelLimitInfo, 'provider'>;
+
+/** A failed model call reduced to the parts a limit dialect reads. */
+export interface IModelCallFailure {
+  /** When the failure was observed, in epoch milliseconds; relative reset times count from here. */
+  observedAt: number;
+  /** HTTP status of the failed response, when the provider reported one. */
+  statusCode?: number;
+  /** Response headers with lower-case names. */
+  headers: Readonly<Record<string, string>>;
+  /** The parsed JSON error body, or the error frame of a failed stream. */
+  body?: unknown;
+}
+
+/** Reads one provider's limit dialect; returns undefined for failures that are not limits. */
+export type TModelLimitClassifier = (failure: IModelCallFailure) => TModelLimitClassification | undefined;
+
+export interface IModelLimitMiddlewareOptions {
+  provider: string;
+  classify: TModelLimitClassifier;
+}
+
+/** Upper bound for the provider, plan and window names a limit carries. */
+export const MODEL_LIMIT_TEXT_MAX_LENGTH = 128;
+
+/** The latest instant a Date can represent, in epoch milliseconds. */
+const MAX_DATE_EPOCH_MS = 8_640_000_000_000_000;
+
+const modelLimitKinds: readonly TModelLimitKind[] = ['usage_limit', 'rate_limit'];
+const modelLimitKeys: ReadonlySet<string> = new Set([
+  'kind',
+  'provider',
+  'resetsAt',
+  'retryAfterMs',
+  'planType',
+  'window',
+]);
+const modelLimitLabels: Record<TModelLimitKind, string> = {
+  usage_limit: 'Usage limit',
+  rate_limit: 'Rate limit',
+};
+const modelLimitErrorMarker = Symbol.for('@modelprofile.com/flexharness-models/ModelLimitError');
+
+/** The value as a JSON object, or undefined for arrays, primitives and null. */
+export function readJsonRecord(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function isLimitText(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0 && value.length <= MODEL_LIMIT_TEXT_MAX_LENGTH;
+}
+
+function isLimitDelay(value: unknown): value is number {
+  return Number.isSafeInteger(value) && (value as number) >= 0;
+}
+
+function isLimitInstant(value: unknown): value is number {
+  return isLimitDelay(value) && value <= MAX_DATE_EPOCH_MS;
+}
+
+/** Whether a value is a complete, bounded limit description. */
+export function isModelLimitInfo(value: unknown): value is IModelLimitInfo {
+  const limit = readJsonRecord(value);
+  if (!limit || Object.keys(limit).some((key) => !modelLimitKeys.has(key))) return false;
+  return modelLimitKinds.includes(limit.kind as TModelLimitKind)
+    && isLimitText(limit.provider)
+    && (limit.resetsAt === undefined || isLimitInstant(limit.resetsAt))
+    && (limit.retryAfterMs === undefined || isLimitDelay(limit.retryAfterMs))
+    && (limit.planType === undefined || isLimitText(limit.planType))
+    && (limit.window === undefined || isLimitText(limit.window));
+}
+
+/** A short sentence naming the limit and, when known, its reset time. */
+export function describeModelLimit(limit: IModelLimitInfo): string {
+  const label = modelLimitLabels[limit.kind];
+  return limit.resetsAt === undefined
+    ? `${label} reached.`
+    : `${label} reached; resets at ${new Date(limit.resetsAt).toISOString()}.`;
+}
+
+/** A provider refused a model call because a usage or rate limit was reached. */
+export class ModelLimitError extends Error {
+  public readonly limit: Readonly<IModelLimitInfo>;
+
+  constructor(limit: IModelLimitInfo, options?: ErrorOptions) {
+    if (!isModelLimitInfo(limit)) throw new TypeError('ModelLimitError requires a valid limit description.');
+    super(describeModelLimit(limit), options);
+    this.name = 'ModelLimitError';
+    this.limit = Object.freeze({ ...limit });
+    Object.defineProperty(this, modelLimitErrorMarker, { value: true });
+  }
+}
+
+/** Recognizes a ModelLimitError, also one created by another copy of this package. */
+export function isModelLimitError(error: unknown): error is ModelLimitError {
+  return error instanceof Error
+    && (error as Error & Record<symbol, unknown>)[modelLimitErrorMarker] === true;
+}
+
+/** Reads `retry-after-ms`, then `retry-after` in seconds or as an HTTP date, from lower-case headers. */
+export function readRetryAfterMs(
+  headers: Readonly<Record<string, string>> | undefined,
+  now = Date.now(),
+): number | undefined {
+  const milliseconds = Number.parseFloat(headers?.['retry-after-ms'] ?? '');
+  if (Number.isFinite(milliseconds) && milliseconds >= 0) return Math.ceil(milliseconds);
+  const retryAfter = headers?.['retry-after'];
+  if (retryAfter === undefined) return undefined;
+  const seconds = Number.parseFloat(retryAfter);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds * 1000);
+  const delay = Date.parse(retryAfter) - now;
+  return Number.isFinite(delay) && delay > 0 ? Math.ceil(delay) : undefined;
+}
+
+/** Converts a Unix timestamp in seconds, as a number or numeric string, to epoch milliseconds. */
+export function readEpochSeconds(value: unknown): number | undefined {
+  const seconds = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+  return typeof seconds === 'number' && Number.isFinite(seconds) && seconds >= 0
+    ? Math.round(seconds * 1000)
+    : undefined;
+}
+
+function lowerCaseHeaders(headers: SharedV4Headers | undefined): Record<string, string> {
+  const normalized: Record<string, string> = {};
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    if (typeof value === 'string') normalized[name.toLowerCase()] = value;
+  }
+  return normalized;
+}
+
+function parseJsonBody(body: string | undefined): unknown {
+  if (body === undefined) return undefined;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+
+/**
+ * A limit from provider-reported values, which are untrusted: a delay or reset time outside the
+ * representable range and an overlong plan or window name are dropped, and a missing reset time
+ * follows from the delay. Kind and provider are kept as given.
+ */
+export function createModelLimitInfo(reported: IModelLimitInfo, observedAt: number): IModelLimitInfo {
+  const retryAfterMs = isLimitDelay(reported.retryAfterMs) ? reported.retryAfterMs : undefined;
+  const resetsAt = [reported.resetsAt, retryAfterMs === undefined ? undefined : observedAt + retryAfterMs]
+    .find(isLimitInstant);
+  return {
+    kind: reported.kind,
+    provider: reported.provider,
+    ...(resetsAt === undefined ? {} : { resetsAt }),
+    ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    ...(isLimitText(reported.planType) ? { planType: reported.planType } : {}),
+    ...(isLimitText(reported.window) ? { window: reported.window } : {}),
+  };
+}
+
+function describeFailure(
+  error: unknown,
+  streamHeaders: SharedV4Headers | undefined,
+  observedAt: number,
+): IModelCallFailure {
+  if (APICallError.isInstance(error)) {
+    return {
+      observedAt,
+      ...(error.statusCode === undefined ? {} : { statusCode: error.statusCode }),
+      headers: lowerCaseHeaders(error.responseHeaders),
+      body: parseJsonBody(error.responseBody) ?? error.data,
+    };
+  }
+  return { observedAt, headers: lowerCaseHeaders(streamHeaders), body: error };
+}
+
+function completeLimit(
+  provider: string,
+  classification: TModelLimitClassification,
+  failure: IModelCallFailure,
+): IModelLimitInfo {
+  return createModelLimitInfo({
+    ...classification,
+    provider,
+    retryAfterMs: classification.retryAfterMs ?? readRetryAfterMs(failure.headers, failure.observedAt),
+  }, failure.observedAt);
+}
+
+/**
+ * Turns the failures a provider dialect recognizes as limits into ModelLimitError, keeping the
+ * original failure as its cause. Covers thrown call errors and error parts of a running stream.
+ */
+export function createModelLimitMiddleware(options: IModelLimitMiddlewareOptions): LanguageModelV4Middleware {
+  const classifyError = (error: unknown, streamHeaders?: SharedV4Headers): unknown => {
+    if (isModelLimitError(error)) return error;
+    const failure = describeFailure(error, streamHeaders, Date.now());
+    const classification = options.classify(failure);
+    return classification === undefined
+      ? error
+      : new ModelLimitError(completeLimit(options.provider, classification, failure), { cause: error });
+  };
+  const call = async <TResult>(operation: () => PromiseLike<TResult>): Promise<TResult> => {
+    try {
+      return await operation();
+    } catch (error) {
+      throw classifyError(error);
+    }
+  };
+  return {
+    specificationVersion: 'v4',
+    wrapGenerate: ({ doGenerate }) => call(doGenerate),
+    wrapStream: async ({ doStream }) => {
+      const result = await call(doStream);
+      const headers = result.response?.headers;
+      return {
+        ...result,
+        stream: result.stream.pipeThrough(new TransformStream<LanguageModelV4StreamPart, LanguageModelV4StreamPart>({
+          transform: (part, controller) => {
+            controller.enqueue(part.type === 'error' ? { ...part, error: classifyError(part.error, headers) } : part);
+          },
+        })),
+      };
+    },
+  };
+}