mirror of
https://github.com/morluto/rea.git
synced 2026-11-20 05:32:44 +00:00
fix(model): project the enforced parser limit and cause (#12399)
This commit is contained in:
1 parent
2773327843
commit
bd4339ade9
5 files changed
+201
-131
No files matched your search
@@ -102,7 +102,7 @@
|
||||
"src/kuna/KunaReferenceQueries.ts": 1,
|
||||
"src/kuna/KunaSessionClient.ts": 1,
|
||||
"src/main/StdioStartupInput.ts": 1,
|
||||
"src/model/ModelArtifactProvider.ts": 3,
|
||||
"src/model/ModelArtifactProvider.ts": 2,
|
||||
"src/native/AppleDispatchMetadata.ts": 1,
|
||||
"src/native/LldbCallTracer.ts": 1,
|
||||
"src/native/NativeCommandAnalysisError.ts": 1,
|
||||
|
||||
@@ -41,13 +41,10 @@ import { GgufHeader } from "./GgufHeader.js";
|
||||
import { readSafetensorsHeader } from "./SafetensorsHeader.js";
|
||||
import {
|
||||
modelCapacityFailure,
|
||||
modelCapacityLimitOf,
|
||||
modelCapacityConstraint,
|
||||
MODEL_REPORT_BYTES,
|
||||
modelCapacityRemediation,
|
||||
modelCapacityReportedLimits,
|
||||
} from "./ModelFormat.js";
|
||||
import { jsonValueByteLength } from "../domain/jsonValueByteLength.js";
|
||||
import { ParseFailureError } from "../domain/parseFailure.js";
|
||||
import { parseFailureAnalysisError } from "../domain/parseFailureAnalysisError.js";
|
||||
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
|
||||
import {
|
||||
@@ -110,10 +107,7 @@ export class ModelArtifactProvider implements ModelArtifactPort {
|
||||
);
|
||||
} catch (cause) {
|
||||
const { cause: primary, origin } = artifactFilePrimaryFacts(cause);
|
||||
const capacity =
|
||||
primary instanceof ParseFailureError
|
||||
? modelCapacityLimitOf(primary)
|
||||
: undefined;
|
||||
const capacityError = modelCapacityConstraint(OPERATION, primary);
|
||||
const formatError = parseFailureAnalysisError(
|
||||
OPERATION,
|
||||
input.path,
|
||||
@@ -122,19 +116,7 @@ export class ModelArtifactProvider implements ModelArtifactPort {
|
||||
let error: AnalysisError;
|
||||
if (origin === "owned-or-classified" && primary instanceof AnalysisError)
|
||||
error = primary;
|
||||
else if (primary instanceof ParseFailureError && capacity !== undefined)
|
||||
// A model allowance names its own recovery.
|
||||
error = new AnalysisResourceConstraintError(
|
||||
OPERATION,
|
||||
"memory",
|
||||
primary.message,
|
||||
modelCapacityReportedLimits(capacity),
|
||||
{
|
||||
cause,
|
||||
retryable: false,
|
||||
remediationAction: modelCapacityRemediation(capacity),
|
||||
},
|
||||
);
|
||||
else if (capacityError !== undefined) error = capacityError;
|
||||
else if (formatError !== undefined) error = formatError;
|
||||
else if (
|
||||
origin === "owned-or-classified" &&
|
||||
|
||||
+63
-76
@@ -1,22 +1,14 @@
|
||||
import { Budget } from "../domain/budget.js";
|
||||
import {
|
||||
decodeLimit,
|
||||
malformedInput,
|
||||
ParseFailureError,
|
||||
type ParseFailureError,
|
||||
unsupportedInput,
|
||||
} from "../domain/parseFailure.js";
|
||||
|
||||
/** Producing constraint for a model capacity refusal. Recovery uses this, not message text. */
|
||||
export const MODEL_CAPACITY_LIMITS = [
|
||||
"header-bytes",
|
||||
"report-bytes",
|
||||
"representation-bytes",
|
||||
"exact-offset",
|
||||
"metadata-nesting",
|
||||
"json-nesting",
|
||||
] as const;
|
||||
|
||||
/** Which fixed model allowance refused the request. */
|
||||
export type ModelCapacityLimit = (typeof MODEL_CAPACITY_LIMITS)[number];
|
||||
import {
|
||||
isParseLimit,
|
||||
parseLimitConstraint,
|
||||
} from "../domain/parseFailureAnalysisError.js";
|
||||
|
||||
/** The ParseFailure format of GGUF and Safetensors model headers. */
|
||||
export const MODEL_FORMAT = "model";
|
||||
@@ -26,25 +18,11 @@ export const modelCapacityFailure = (
|
||||
limit: ModelCapacityLimit,
|
||||
detail: string,
|
||||
): ParseFailureError<"limit"> =>
|
||||
new ParseFailureError({
|
||||
kind: "limit",
|
||||
format: MODEL_FORMAT,
|
||||
detail,
|
||||
limit: {
|
||||
name: limit,
|
||||
maximum: Object.values(modelCapacityReportedLimits(limit))[0] ?? 0,
|
||||
},
|
||||
decodeLimit(MODEL_FORMAT, detail, {
|
||||
name: limit,
|
||||
maximum: modelCapacityLimits[limit].maximum,
|
||||
});
|
||||
|
||||
/** The model allowance a failure names, or undefined for any other failure. */
|
||||
export const modelCapacityLimitOf = (
|
||||
cause: ParseFailureError,
|
||||
): ModelCapacityLimit | undefined => {
|
||||
const { failure } = cause;
|
||||
if (failure.kind !== "limit") return undefined;
|
||||
return MODEL_CAPACITY_LIMITS.find((limit) => limit === failure.limit.name);
|
||||
};
|
||||
|
||||
export function rejectModel(message: string): never {
|
||||
throw malformedInput(MODEL_FORMAT, message);
|
||||
}
|
||||
@@ -68,52 +46,61 @@ export const MODEL_JSON_NESTING = 32;
|
||||
const fixedModelLimit = (allowance: string): string =>
|
||||
`${allowance}. This release has no runtime override. Additional host memory does not raise it. Repeating the unchanged request fails the same way.`;
|
||||
|
||||
/** Recovery for the allowance that actually refused the model. Host memory does not raise it. */
|
||||
export const modelCapacityRemediation = (limit: ModelCapacityLimit): string => {
|
||||
switch (limit) {
|
||||
case "header-bytes":
|
||||
return fixedModelLimit("The model header allowance is 100,000,000 bytes");
|
||||
case "report-bytes":
|
||||
return fixedModelLimit(
|
||||
`The retained model report allowance is ${String(MODEL_REPORT_BYTES)} bytes`,
|
||||
);
|
||||
case "representation-bytes":
|
||||
return fixedModelLimit(
|
||||
`The retained model representation allowance is ${String(MODEL_REPORT_BYTES)} bytes`,
|
||||
);
|
||||
case "exact-offset":
|
||||
return fixedModelLimit(
|
||||
`Exact host offset precision stops at ${String(Number.MAX_SAFE_INTEGER)}`,
|
||||
);
|
||||
case "metadata-nesting":
|
||||
return fixedModelLimit(
|
||||
`GGUF metadata nesting is limited to ${String(MODEL_METADATA_NESTING)} array frames`,
|
||||
);
|
||||
case "json-nesting":
|
||||
return fixedModelLimit(
|
||||
`Safetensors JSON nesting is limited to ${String(MODEL_JSON_NESTING)} levels`,
|
||||
);
|
||||
}
|
||||
};
|
||||
const modelCapacityLimits = {
|
||||
"header-bytes": {
|
||||
maximum: MODEL_HEADER_BYTES,
|
||||
legacyMaximumKey: "maximum_header_bytes",
|
||||
allowance: (maximum: number) =>
|
||||
`The model header allowance is ${maximum.toLocaleString("en-US")} bytes`,
|
||||
},
|
||||
"report-bytes": {
|
||||
maximum: MODEL_REPORT_BYTES,
|
||||
legacyMaximumKey: "maximum_report_bytes",
|
||||
allowance: (maximum: number) =>
|
||||
`The retained model report allowance is ${String(maximum)} bytes`,
|
||||
},
|
||||
"representation-bytes": {
|
||||
maximum: MODEL_REPORT_BYTES,
|
||||
legacyMaximumKey: "maximum_representation_bytes",
|
||||
allowance: (maximum: number) =>
|
||||
`The retained model representation allowance is ${String(maximum)} bytes`,
|
||||
},
|
||||
"exact-offset": {
|
||||
maximum: Number.MAX_SAFE_INTEGER,
|
||||
legacyMaximumKey: "maximum_exact_offset",
|
||||
allowance: (maximum: number) =>
|
||||
`Exact host offset precision stops at ${String(maximum)}`,
|
||||
},
|
||||
"metadata-nesting": {
|
||||
maximum: MODEL_METADATA_NESTING,
|
||||
legacyMaximumKey: "maximum_array_frames",
|
||||
allowance: (maximum: number) =>
|
||||
`GGUF metadata nesting is limited to ${String(maximum)} array frames`,
|
||||
},
|
||||
"json-nesting": {
|
||||
maximum: MODEL_JSON_NESTING,
|
||||
legacyMaximumKey: "maximum_json_depth",
|
||||
allowance: (maximum: number) =>
|
||||
`Safetensors JSON nesting is limited to ${String(maximum)} levels`,
|
||||
},
|
||||
} as const;
|
||||
|
||||
/** Limits that belong to the producing constraint, without unrelated ceilings. */
|
||||
export const modelCapacityReportedLimits = (
|
||||
limit: ModelCapacityLimit,
|
||||
): Readonly<Record<string, number>> => {
|
||||
switch (limit) {
|
||||
case "header-bytes":
|
||||
return { maximum_header_bytes: MODEL_HEADER_BYTES };
|
||||
case "report-bytes":
|
||||
return { maximum_report_bytes: MODEL_REPORT_BYTES };
|
||||
case "representation-bytes":
|
||||
return { maximum_representation_bytes: MODEL_REPORT_BYTES };
|
||||
case "exact-offset":
|
||||
return { maximum_exact_offset: Number.MAX_SAFE_INTEGER };
|
||||
case "metadata-nesting":
|
||||
return { maximum_array_frames: MODEL_METADATA_NESTING };
|
||||
case "json-nesting":
|
||||
return { maximum_json_depth: MODEL_JSON_NESTING };
|
||||
}
|
||||
type ModelCapacityLimit = keyof typeof modelCapacityLimits;
|
||||
|
||||
const isModelCapacityLimit = (name: string): name is ModelCapacityLimit =>
|
||||
Object.hasOwn(modelCapacityLimits, name);
|
||||
|
||||
/** The model parser supplies the enforced maximum and the original cause. */
|
||||
export const modelCapacityConstraint = (operation: string, cause: unknown) => {
|
||||
if (!isParseLimit(cause, MODEL_FORMAT)) return undefined;
|
||||
const { name, maximum } = cause.failure.limit;
|
||||
if (!isModelCapacityLimit(name)) return undefined;
|
||||
const { allowance, legacyMaximumKey } = modelCapacityLimits[name];
|
||||
return parseLimitConstraint(operation, "memory", cause, {
|
||||
legacyMaximumKey,
|
||||
retryable: false,
|
||||
remediationAction: fixedModelLimit(allowance(maximum)),
|
||||
});
|
||||
};
|
||||
|
||||
/** Charge representation growth before retaining rows or decoding long strings. */
|
||||
|
||||
@@ -9,8 +9,8 @@ import {
|
||||
MODEL_JSON_NESTING,
|
||||
MODEL_METADATA_NESTING,
|
||||
MODEL_REPORT_BYTES,
|
||||
modelCapacityRemediation,
|
||||
modelCapacityReportedLimits,
|
||||
modelCapacityConstraint,
|
||||
modelCapacityFailure,
|
||||
} from "../../../src/model/ModelFormat.js";
|
||||
import { readSafetensorsHeader } from "../../../src/model/SafetensorsHeader.js";
|
||||
import { ParseFailureError } from "../../../src/domain/parseFailure.js";
|
||||
@@ -946,36 +946,50 @@ it.each([
|
||||
},
|
||||
);
|
||||
|
||||
it("chooses model recovery from the producing limit", () => {
|
||||
const header = modelCapacityRemediation("header-bytes");
|
||||
expect(header).toContain("100,000,000 bytes");
|
||||
expect(header).not.toContain("Safetensors");
|
||||
expect(header).not.toContain(String(MODEL_REPORT_BYTES));
|
||||
const report = modelCapacityRemediation("report-bytes");
|
||||
expect(report).toContain(`report allowance is ${String(MODEL_REPORT_BYTES)}`);
|
||||
expect(report).not.toContain("representation");
|
||||
const representation = modelCapacityRemediation("representation-bytes");
|
||||
expect(representation).toContain("representation allowance");
|
||||
expect(representation).not.toContain("report allowance");
|
||||
const offset = modelCapacityRemediation("exact-offset");
|
||||
expect(offset).toContain(String(Number.MAX_SAFE_INTEGER));
|
||||
expect(offset).not.toContain(String(MODEL_REPORT_BYTES));
|
||||
const nesting = modelCapacityRemediation("metadata-nesting");
|
||||
expect(nesting).toContain(`${String(MODEL_METADATA_NESTING)} array frames`);
|
||||
expect(nesting).not.toContain(String(MODEL_REPORT_BYTES));
|
||||
const jsonNesting = modelCapacityRemediation("json-nesting");
|
||||
expect(jsonNesting).toContain(`${String(MODEL_JSON_NESTING)} levels`);
|
||||
expect(jsonNesting).not.toContain(String(MODEL_REPORT_BYTES));
|
||||
expect(modelCapacityReportedLimits("report-bytes")).toEqual({
|
||||
maximum_report_bytes: MODEL_REPORT_BYTES,
|
||||
});
|
||||
expect(modelCapacityReportedLimits("exact-offset")).toEqual({
|
||||
maximum_exact_offset: Number.MAX_SAFE_INTEGER,
|
||||
});
|
||||
expect(modelCapacityReportedLimits("json-nesting")).toEqual({
|
||||
maximum_json_depth: MODEL_JSON_NESTING,
|
||||
});
|
||||
});
|
||||
it.each([
|
||||
[
|
||||
"header-bytes",
|
||||
{ maximum_header_bytes: 100_000_000 },
|
||||
"header allowance is 100,000,000 bytes",
|
||||
],
|
||||
[
|
||||
"report-bytes",
|
||||
{ maximum_report_bytes: MODEL_REPORT_BYTES },
|
||||
`report allowance is ${String(MODEL_REPORT_BYTES)} bytes`,
|
||||
],
|
||||
[
|
||||
"representation-bytes",
|
||||
{ maximum_representation_bytes: MODEL_REPORT_BYTES },
|
||||
`representation allowance is ${String(MODEL_REPORT_BYTES)} bytes`,
|
||||
],
|
||||
[
|
||||
"exact-offset",
|
||||
{ maximum_exact_offset: Number.MAX_SAFE_INTEGER },
|
||||
`offset precision stops at ${String(Number.MAX_SAFE_INTEGER)}`,
|
||||
],
|
||||
[
|
||||
"metadata-nesting",
|
||||
{ maximum_array_frames: MODEL_METADATA_NESTING },
|
||||
`GGUF metadata nesting is limited to ${String(MODEL_METADATA_NESTING)} array frames`,
|
||||
],
|
||||
[
|
||||
"json-nesting",
|
||||
{ maximum_json_depth: MODEL_JSON_NESTING },
|
||||
`Safetensors JSON nesting is limited to ${String(MODEL_JSON_NESTING)} levels`,
|
||||
],
|
||||
] as const)(
|
||||
"projects legacy fields and recovery for %s",
|
||||
(limit, reportedLimits, remediation) => {
|
||||
const cause = modelCapacityFailure(limit, "Model allowance exhausted");
|
||||
const error = modelCapacityConstraint("inspect_model_artifact", cause);
|
||||
expect(error).toMatchObject({
|
||||
reason: "Model allowance exhausted",
|
||||
remediationAction: expect.stringContaining(remediation),
|
||||
cause,
|
||||
});
|
||||
expect(error?.reportedLimits).toEqual(reportedLimits);
|
||||
},
|
||||
);
|
||||
|
||||
it("refuses an oversized declared header before reading or expanding it", async () => {
|
||||
const bytes = Buffer.alloc(9);
|
||||
|
||||
@@ -80,6 +80,7 @@ import {
|
||||
} from "../../src/domain/analysisErrorBase.js";
|
||||
import { createEvidence, parseEvidence } from "../../src/domain/evidence.js";
|
||||
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
|
||||
import { ParseFailureError } from "../../src/domain/parseFailure.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisInputError,
|
||||
@@ -151,7 +152,7 @@ import { inspectWindowsShortcutInputSchema } from "../../src/domain/native/windo
|
||||
import { inspectNativeExportsInputSchema } from "../../src/domain/native/nativeExports.js";
|
||||
import { inspectErlangBeamInputSchema } from "../../src/domain/erlang/beam.js";
|
||||
import { ModelArtifactProvider } from "../../src/model/ModelArtifactProvider.js";
|
||||
import { ggufFixture } from "../fixtures/model/model.js";
|
||||
import { ggufFixture, safetensorsFixture } from "../fixtures/model/model.js";
|
||||
import { inspectPeResourcesInputSchema } from "../../src/domain/native/peResources.js";
|
||||
import { peResourceFixture } from "../../src/domain/pe/peResources.fixture.js";
|
||||
import { createServer } from "../../src/server/createServer.js";
|
||||
@@ -697,6 +698,92 @@ it("preserves a model permission failure when cancellation arrives during close"
|
||||
}
|
||||
});
|
||||
|
||||
it("keeps the model parser cause through failed close and retry", async () => {
|
||||
const path = await selectedImage();
|
||||
const fixture = (depth: number) => {
|
||||
const nested = "[".repeat(depth) + "0" + "]".repeat(depth);
|
||||
return safetensorsFixture(
|
||||
`{"weight":{"dtype":"F32","shape":[1],"data_offsets":[0,4],"note":${nested}}}`,
|
||||
Buffer.alloc(4),
|
||||
).bytes;
|
||||
};
|
||||
const provider = new ModelArtifactProvider();
|
||||
try {
|
||||
fault.blockNew = false;
|
||||
await writeFile(path, fixture(1));
|
||||
const valid = await provider.inspect({ path, hash: "header" });
|
||||
expect(valid).toMatchObject({
|
||||
ok: true,
|
||||
value: { tensors: [{ name: "weight" }] },
|
||||
});
|
||||
|
||||
fault.blockNew = true;
|
||||
await writeFile(path, fixture(33));
|
||||
const result = await provider.inspect({ path, hash: "header" });
|
||||
if (result.ok) throw new Error("Expected a model depth refusal");
|
||||
const { error } = result;
|
||||
const maximum = { maximum_json_depth: 32 };
|
||||
expect(projectAnalysisError(error)).toMatchObject({
|
||||
code: "cleanup_incomplete",
|
||||
details: { reported_limits: maximum },
|
||||
});
|
||||
expect(error.cleanupPrimary?.cause).toBeInstanceOf(ParseFailureError);
|
||||
expect(error.cleanupPrimary?.cause).toMatchObject({
|
||||
failure: {
|
||||
format: "model",
|
||||
kind: "limit",
|
||||
limit: { name: "json-nesting", maximum: 32 },
|
||||
},
|
||||
});
|
||||
const retained = fault.handles.at(-1);
|
||||
expect(retained?.fd).toBeGreaterThanOrEqual(0);
|
||||
fault.blocked.clear();
|
||||
await provider.close();
|
||||
expect(retained?.fd).toBe(-1);
|
||||
expect(projectAnalysisError(error)).toMatchObject({
|
||||
code: "resource_constraint",
|
||||
details: { reported_limits: maximum },
|
||||
});
|
||||
expect(resolvedAnalysisError(error).cause).toBe(
|
||||
error.cleanupPrimary?.cause,
|
||||
);
|
||||
} finally {
|
||||
fault.blocked.clear();
|
||||
await provider.close();
|
||||
}
|
||||
});
|
||||
|
||||
it.each(["model", "foreign-fixture"])(
|
||||
"projects only a model-owned parser limit with its enforced maximum (%s)",
|
||||
async (format) => {
|
||||
const path = await selectedImage();
|
||||
const injected = new ParseFailureError({
|
||||
format,
|
||||
kind: "limit",
|
||||
detail: "fixture-owned parser limit",
|
||||
limit: { name: "json-nesting", maximum: 17 },
|
||||
});
|
||||
fault.blockNew = false;
|
||||
fault.laterReadFailure = { position: 0, cause: injected };
|
||||
const provider = new ModelArtifactProvider();
|
||||
try {
|
||||
const result = await provider.inspect({ path, hash: "header" });
|
||||
if (result.ok) throw new Error("Expected a read refusal");
|
||||
expect(result.error.cause).toBe(injected);
|
||||
const projected = projectAnalysisError(result.error);
|
||||
if (format === "model")
|
||||
expect(projected).toMatchObject({
|
||||
code: "resource_constraint",
|
||||
details: { reported_limits: { maximum_json_depth: 17 } },
|
||||
remediation: { action: expect.stringContaining("17 levels") },
|
||||
});
|
||||
else expect(projected.code).toBe("execution_failure");
|
||||
} finally {
|
||||
await provider.close();
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it("retains earlier GGUF rows and physical failure while retrying failed descriptor cleanup", async () => {
|
||||
const path = await selectedImage();
|
||||
const seed = ggufFixture();
|
||||
|
||||
Reference in new issue
Block a user