@rulvar/core 1.74.0 → 1.75.0

package/dist/index.d.ts

@@ -1531,7 +1531,17 @@ type ModelCaps = {
   supportsParallelTools: boolean; /** Canonical efforts this model accepts after mapping. */
   reasoningEfforts: Effort[];
   contextWindow: number;
-  maxOutputTokens: number; /** Adapter-reported fallback only; the versioned price table wins. */
+  maxOutputTokens: number;
+  /**
+  * The smallest request output cap the provider accepts (the v1.74
+  * experiment review, P0.1): OpenAI's Responses API rejects
+  * max_output_tokens below 16, so a dispatch under this floor is a
+  * guaranteed 400. The runtime never sends a request output cap below
+  * it: a budget last gasp dispatches the floor instead of one token,
+  * and a remainder that cannot buy the floor is refused typed before
+  * the wire. Absent means one, the historical floor.
+  */
+  minOutputTokensPerTurn?: number; /** Adapter-reported fallback only; the versioned price table wins. */
   pricing?: Pricing;
 };
 interface ProviderAdapter {

package/dist/index.js

@@ -10181,31 +10181,53 @@ function estimateInputTokens(messages) {
 	return Math.ceil(chars / 4);
 }
 /**
+* The serving model's declared minimum request output cap, default one.
+* OpenAI's Responses API rejects max_output_tokens below 16, so a
+* below-floor dispatch is a guaranteed provider 400: the v1.74
+* experiment's terminal repair died exactly there (the review, P0.1).
+* Defensive lookup: a caps() throw must not fail turns that never
+* consulted caps at this point before.
+*/
+function outputFloorOf(target) {
+	try {
+		const declared = target.adapter.caps(target.resolved.model).minOutputTokensPerTurn;
+		return declared !== void 0 && Number.isInteger(declared) && declared > 1 ? declared : 1;
+	} catch {
+		return 1;
+	}
+}
+/**
 * Layer 2b at the wire boundary: clamps the outgoing request's
 * maxOutputTokens to what the remaining budget affords from the serving
-* model. The clamp uses the heuristic prompt estimate; the DENIAL does
-* not: a turn is refused (BudgetExhaustedError, never dispatched) only
-* when the remainder cannot buy even ONE output token at zero input,
-* which is exact. Denying on the estimate would kill turns the budget
-* still funds, including the DEF-7 forced finish paid from the released
-* finalize reserve; when the estimate says the prompt alone spends the
-* remainder, the turn dispatches with a one-token output floor and the
-* exact layers (2 and 3) settle the difference. A no-op without a hook
-* or when the hook reports no bound. The clamp touches only the wire
-* request, exactly like limits.maxOutputTokensPerTurn above it; identity
-* is computed at the ctx layer and never sees it.
+* model, and holds every dispatch at or above the serving model's
+* output floor. The clamp uses the heuristic prompt estimate; the
+* DENIAL does not: a turn is refused (BudgetExhaustedError, never
+* dispatched) only when the remainder cannot buy the floor at zero
+* input, which is exact. Denying on the estimate would kill turns the
+* budget still funds, including the DEF-7 forced finish paid from the
+* released finalize reserve; when the estimate says the prompt alone
+* spends the remainder, the turn dispatches AT the floor and the exact
+* layers (2 and 3) settle the difference. A configured per-turn cap
+* below the floor is a ConfigError before any wire call: the provider
+* would reject every dispatch, so failing typed beats paying for a
+* guaranteed 400. A no-op without a hook or when the hook reports no
+* bound. The clamp touches only the wire request, exactly like
+* limits.maxOutputTokensPerTurn above it; identity is computed at the
+* ctx layer and never sees it.
 */
 function applyOutputBudget(req, target, budget) {
+	const floor = outputFloorOf(target);
+	if (req.maxOutputTokens !== void 0 && req.maxOutputTokens < floor) throw new ConfigError(`the per-turn output cap ${String(req.maxOutputTokens)} is below the ${String(floor)} token output floor of ${target.resolved.ref}; the provider would reject every dispatch, so raise limits.maxOutputTokensPerTurn to at least the floor`);
 	const hook = budget?.maxAffordableOutputTokens;
 	if (hook === void 0) return req;
 	const affordable = hook(target.resolved.ref, estimateInputTokens(req.messages));
 	if (affordable === void 0) return req;
-	if (affordable < 1) {
+	if (affordable < floor) {
 		const zeroInputAffordable = hook(target.resolved.ref, 0);
-		if (zeroInputAffordable !== void 0 && zeroInputAffordable < 1) throw new BudgetExhaustedError(`the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched`);
+		if (zeroInputAffordable !== void 0 && zeroInputAffordable < floor) throw new BudgetExhaustedError(floor === 1 ? `the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched` : `the remaining budget cannot afford the ${String(floor)} token output floor of ${target.resolved.ref}; the turn was not dispatched`);
 		return {
 			...req,
-			maxOutputTokens: 1
+			maxOutputTokens: floor
 		};
 	}
 	if (req.maxOutputTokens === void 0 || affordable < req.maxOutputTokens) return {
@@ -10260,6 +10282,101 @@ function assistantMsg(turn, retained = []) {
 	};
 }
 /**
+* The adapter parse-failure wrapper, recognized by exact shape: both
+* first-class wires deliver tool arguments their single strict
+* JSON.parse rejected as `{__unparsed: raw}` and nothing else.
+*/
+function unparsedMarkerOf(args) {
+	if (typeof args !== "object" || args === null || Array.isArray(args)) return;
+	const keys = Object.keys(args);
+	const raw = args.__unparsed;
+	return keys.length === 1 && keys[0] === "__unparsed" && typeof raw === "string" ? raw : void 0;
+}
+/** JSON.parse to a plain object, or undefined; never throws. */
+function parsePlainObject(text) {
+	try {
+		const value = JSON.parse(text);
+		return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* One bounded deterministic normalization of a near-JSON arguments
+* string: strip a single markdown fence, cut at the end of the first
+* balanced top-level object (drops trailing prose), and escape raw
+* control characters inside string literals (models writing markdown
+* documents into arguments emit real newlines, which strict JSON
+* forbids). Truncated payloads stay unbalanced and still fail the
+* parse; nothing here can invent structure the model did not write.
+*/
+function normalizeNearJson(raw) {
+	let text = raw.trim();
+	const fence = /^```[a-zA-Z]*[\t ]*\r?\n([\s\S]*?)\r?\n?```$/.exec(text);
+	if (fence?.[1] !== void 0) text = fence[1].trim();
+	const start = text.indexOf("{");
+	if (start >= 0) {
+		let depth = 0;
+		let inString = false;
+		let escaped = false;
+		for (let index = start; index < text.length; index += 1) {
+			const char = text[index];
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = inString;
+				continue;
+			}
+			if (char === "\"") {
+				inString = !inString;
+				continue;
+			}
+			if (inString) continue;
+			if (char === "{") depth += 1;
+			else if (char === "}") {
+				depth -= 1;
+				if (depth === 0) {
+					text = text.slice(start, index + 1);
+					break;
+				}
+			}
+		}
+	}
+	let escapedText = "";
+	let inString = false;
+	let escaped = false;
+	for (const char of text) {
+		if (!escaped && char === "\"") inString = !inString;
+		escaped = inString && !escaped && char === "\\";
+		const code = char.codePointAt(0) ?? 0;
+		if (inString && code < 32) escapedText += char === "\n" ? "\\n" : char === "\r" ? "\\r" : char === "	" ? "\\t" : `\\u${code.toString(16).padStart(4, "0")}`;
+		else escapedText += char;
+	}
+	return escapedText;
+}
+/**
+* The deterministic second chance (the v1.74 experiment review, P1.5):
+* a strict re-parse of the wrapped raw string, then one normalization
+* pass. The v1.74 experiment durably proved three complete coordination
+* drafts were recoverable this way and were thrown away instead. Only a
+* plain object counts; the recovered value still faces the tool schema
+* at the caller.
+*/
+function recoverUnparsedArgs(raw) {
+	const strict = parsePlainObject(raw);
+	if (strict !== void 0) return {
+		value: strict,
+		pass: "strict"
+	};
+	const normalized = parsePlainObject(normalizeNearJson(raw));
+	if (normalized !== void 0) return {
+		value: normalized,
+		pass: "normalized"
+	};
+}
+/**
 * Executes one model-issued tool call to a tool-result part. Failures are
 * surfaced to the model as error tool results and never thrown past
 * policy: unknown names, argument-validation issues, ModelRetry (bounded
@@ -10288,7 +10405,22 @@ async function executeToolCall(options) {
 		return part;
 	};
 	if (def === void 0) return finish({ error: `unknown tool '${call.name}'` }, "error");
-	const validation = await validateSchemaSpec(def.parameters, call.args);
+	let validation = await validateSchemaSpec(def.parameters, call.args);
+	if (!validation.valid) {
+		const unparsedRaw = unparsedMarkerOf(call.args);
+		const recovered = unparsedRaw === void 0 ? void 0 : recoverUnparsedArgs(unparsedRaw);
+		if (recovered !== void 0) {
+			const revalidation = await validateSchemaSpec(def.parameters, recovered.value);
+			if (revalidation.valid) {
+				validation = revalidation;
+				options.events?.emit({
+					type: "log",
+					level: "warn",
+					msg: `arguments for '${call.name}' arrived unparsed (${String(unparsedRaw?.length ?? 0)} chars) and were recovered by a ${recovered.pass} JSON pass; the recovered object passed the tool schema and the call executed`
+				});
+			}
+		}
+	}
 	if (!validation.valid) return finish({
 		error: `arguments for '${call.name}' failed validation`,
 		issues: validation.issues.map((issue) => issue.message)
@@ -17564,6 +17696,12 @@ function preflightEstimate(input) {
 			message: `spawn '${label}' sets maxOutputTokensPerTurn ${String(limits.maxOutputTokensPerTurn)} above the model's maxOutputTokens ${String(caps.maxOutputTokens)}: the model clamp wins`,
 			spawn: label
 		});
+		if (caps?.minOutputTokensPerTurn !== void 0 && limits.maxOutputTokensPerTurn !== void 0 && limits.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+			severity: "error",
+			code: "output-cap-below-provider-minimum",
+			message: `spawn '${label}' sets maxOutputTokensPerTurn ${String(limits.maxOutputTokensPerTurn)} below the ${String(caps.minOutputTokensPerTurn)} token output floor of '${servedBy ?? ""}': every dispatch would be refused typed before the wire; raise the cap to at least the floor`,
+			spawn: label
+		});
 		const turnFloorUsd = pricing === void 0 || outputBound === void 0 ? void 0 : priceUsdOf(pricing, {
 			inputTokens: spec.estInputTokens ?? 0,
 			outputTokens: outputBound,
@@ -17692,6 +17830,12 @@ function preflightEstimate(input) {
 			const pricing = pricingOf(servedBy);
 			const orchLimits = mergeUsageLimits(input.orchestrator.limits, void 0, defaults.limits);
 			const outputBound = caps === void 0 ? orchLimits.maxOutputTokensPerTurn : orchLimits.maxOutputTokensPerTurn === void 0 ? caps.maxOutputTokens : Math.min(caps.maxOutputTokens, orchLimits.maxOutputTokensPerTurn);
+			if (caps?.minOutputTokensPerTurn !== void 0 && orchLimits.maxOutputTokensPerTurn !== void 0 && orchLimits.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+				severity: "error",
+				code: "output-cap-below-provider-minimum",
+				message: `the orchestrator sets maxOutputTokensPerTurn ${String(orchLimits.maxOutputTokensPerTurn)} below the ${String(caps.minOutputTokensPerTurn)} token output floor of '${servedBy}': every dispatch would be refused typed before the wire; raise the cap to at least the floor`,
+				spawn: "orchestrator"
+			});
 			const { adapterId, model } = parseModelRef(servedBy);
 			const unit = {
 				label: "orchestrator",
@@ -17739,6 +17883,12 @@ function preflightEstimate(input) {
 				const caps = capsOf(servedBy);
 				const merged = mergeUsageLimits(synthesis.limits ?? { maxTurns: 4 }, void 0, defaults.limits);
 				const outputBound = caps === void 0 ? merged.maxOutputTokensPerTurn : merged.maxOutputTokensPerTurn === void 0 ? caps.maxOutputTokens : Math.min(caps.maxOutputTokens, merged.maxOutputTokensPerTurn);
+				if (caps?.minOutputTokensPerTurn !== void 0 && merged.maxOutputTokensPerTurn !== void 0 && merged.maxOutputTokensPerTurn < caps.minOutputTokensPerTurn) say({
+					severity: "error",
+					code: "output-cap-below-provider-minimum",
+					message: `the synthesis invocation sets maxOutputTokensPerTurn ${String(merged.maxOutputTokensPerTurn)} below the ${String(caps.minOutputTokensPerTurn)} token output floor of '${servedBy}': every dispatch would be refused typed before the wire; raise the cap to at least the floor`,
+					spawn: "synthesis"
+				});
 				const projected = projectedProviderTurnsOf(merged, overallExecutedCeiling(merged, toolCeilingsOf(merged))) + finishRepairReserve;
 				if (orchestratorEcho !== void 0) orchestratorEcho.synthesis = {
 					projectedProviderTurns: projected,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.74.0",
+  "version": "1.75.0",
   "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",