@rulvar/anthropic 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -67,6 +67,12 @@ declare class IdMap {
 }
 type Block = Record<string, unknown>;
 /**
+* Returns a deep copy of the schema with the unsupported keywords
+* removed at SCHEMA positions only: a property literally named
+* "minimum" (a key inside `properties`) survives. The input is never
+* mutated; unrecognized keywords are copied through untouched.
+*/
+/**
 * Builds Messages API params from a ChatRequest. cacheHint compiles into
 * cache_control breakpoints; beyond the provider cap of 4 the DEEPEST
 * breakpoints are kept and the shallowest dropped, deterministically

package/dist/index.js

@@ -54,6 +54,22 @@ const ANTHROPIC_MODELS = {
 		cacheRead: .3,
 		cacheWrite: 3.75
 	}, 2048),
+	"claude-haiku-4-5": (() => {
+		const base = current(2e5, 64e3, {
+			in: 1,
+			out: 5,
+			cacheRead: .1,
+			cacheWrite: 1.25
+		}, 2048);
+		return {
+			...base,
+			caps: {
+				...base.caps,
+				reasoningEfforts: []
+			},
+			thinkingForm: "enabled-budget"
+		};
+	})(),
 	"claude-opus-4-6": {
 		...current(2e5, 32e3, {
 			in: 15,
@@ -126,6 +142,75 @@ var IdMap = class {
 		return wireId;
 	}
 };
+/**
+* Keywords the constrained-decoding schema validator rejects with a
+* live 400 ("For 'integer' type, property 'minimum' is not
+* supported"): every numeric bound plus, asymmetrically, maxItems
+* (minItems, the string bounds, pattern, format, enum and const all
+* pass). The validator guards exactly two wire positions: tools sent
+* with strict: true and output_config.format json_schema; plain tools
+* accept full JSON Schema. Probed live on claude-sonnet-5, 2026-07-11
+* (docs/04, section 4.3). The engine still validates tool args and
+* structured output against the UNSCRUBBED schema, so the dropped
+* keywords stay enforced; only the model-side hint is lost.
+*/
+const CONSTRAINED_DECODING_UNSUPPORTED = /* @__PURE__ */ new Set([
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"maxItems"
+]);
+/** Keywords whose value is a map of property NAMES to schemas. */
+const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"$defs",
+	"definitions"
+]);
+/** Keywords whose value is a schema or an array of schemas. */
+const SCHEMA_VALUE_KEYWORDS = /* @__PURE__ */ new Set([
+	"items",
+	"prefixItems",
+	"additionalProperties",
+	"additionalItems",
+	"propertyNames",
+	"contains",
+	"anyOf",
+	"oneOf",
+	"allOf",
+	"not",
+	"if",
+	"then",
+	"else"
+]);
+/**
+* Returns a deep copy of the schema with the unsupported keywords
+* removed at SCHEMA positions only: a property literally named
+* "minimum" (a key inside `properties`) survives. The input is never
+* mutated; unrecognized keywords are copied through untouched.
+*/
+function scrubForConstrainedDecoding(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => scrubForConstrainedDecoding(entry));
+	if (schema === null || typeof schema !== "object") return schema;
+	const out = {};
+	for (const [key, value] of Object.entries(schema)) {
+		if (CONSTRAINED_DECODING_UNSUPPORTED.has(key)) continue;
+		if (SCHEMA_MAP_KEYWORDS.has(key) && value !== null && typeof value === "object") {
+			const map = {};
+			for (const [name, sub] of Object.entries(value)) map[name] = scrubForConstrainedDecoding(sub);
+			out[key] = map;
+			continue;
+		}
+		if (SCHEMA_VALUE_KEYWORDS.has(key)) {
+			out[key] = scrubForConstrainedDecoding(value);
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
 function cacheControl(ttl) {
 	return ttl === "1h" ? {
 		type: "ephemeral",
@@ -203,12 +288,15 @@ function buildAnthropicParams(req, options) {
 	if (systemBlocks.length > 0) params.system = systemBlocks;
 	if (req.stopSequences !== void 0) params.stop_sequences = req.stopSequences;
 	if (req.tools !== void 0) {
-		params.tools = req.tools.map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			input_schema: tool.parameters,
-			...isStrictCompatibleSchema(tool.parameters) ? { strict: true } : {}
-		}));
+		params.tools = req.tools.map((tool) => {
+			const strict = isStrictCompatibleSchema(tool.parameters);
+			return {
+				name: tool.name,
+				description: tool.description,
+				input_schema: strict ? scrubForConstrainedDecoding(tool.parameters) : tool.parameters,
+				...strict ? { strict: true } : {}
+			};
+		});
 		if (req.toolChoice === "required") params.tool_choice = { type: "any" };
 		else if (typeof req.toolChoice === "object") params.tool_choice = {
 			type: "tool",
@@ -222,7 +310,7 @@ function buildAnthropicParams(req, options) {
 	if (req.effort !== void 0) outputConfig.effort = req.effort;
 	if (req.schema !== void 0) outputConfig.format = {
 		type: "json_schema",
-		schema: req.schema
+		schema: scrubForConstrainedDecoding(req.schema)
 	};
 	if (anthropicOptions.task_budget !== void 0) outputConfig.task_budget = anthropicOptions.task_budget;
 	if (Object.keys(outputConfig).length > 0) params.output_config = outputConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/anthropic",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "rulvar first-class provider adapter over @anthropic-ai/sdk.",
   "type": "module",
   "license": "Apache-2.0",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.110.0",
-    "@rulvar/core": "1.0.0"
+    "@rulvar/core": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",