@steve31415/baselib 3.29.0 → 3.30.0

package/dist/llm/providers/anthropic.js

@@ -13,32 +13,35 @@ function classifyFinish(stopReason) {
     }
 }
 /**
- * Keywords `output_config.format` rejects outright with a 400 (verified on
- * Opus 5.5, 2026-09-22). `minItems` is also rejected for values other than 0
- * or 1, handled separately; `minLength`/`maxLength`, `pattern` and `format`
- * are accepted.
+ * Keywords Anthropic's constrained decoding rejects outright with a 400 —
+ * `output_config.format` (verified on Opus 5.5, 2026-09-22) and strict tools
+ * alike (verified on every forced-tool registry model, 2026-10-07). `minItems`
+ * is also rejected for values other than 0 or 1, handled separately;
+ * `minLength`/`maxLength`, `pattern`, `format` and nullable unions are
+ * accepted.
  */
-const UNSUPPORTED_FORMAT_KEYWORDS = [
+const UNSUPPORTED_STRICT_KEYWORDS = [
     'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
     'maxItems', 'uniqueItems',
 ];
 /**
- * Transform a portable JSON schema into the dialect Anthropic's structured
- * outputs (`output_config.format`) accepts: every object schema must set
- * `additionalProperties: false`, and the numeric/array bounds listed above are
- * dropped. The model then no longer enforces those bounds — callers validate
- * the parsed result as they already must for truncation. Unlike forced
- * tool_use, optional properties stay optional. Returns a deep copy — the
- * caller's schema object is reused across failover attempts.
+ * Transform a portable JSON schema into the dialect Anthropic's constrained
+ * decoding accepts (`output_config.format` and `strict: true` tools): every
+ * object schema must set `additionalProperties: false`, and the numeric/array
+ * bounds listed above are dropped. The model then no longer enforces those
+ * bounds — callers validate the parsed result as they already must for
+ * truncation. Optional properties stay optional (unlike OpenAI's strict
+ * dialect). Returns a deep copy — the caller's schema object is reused across
+ * failover attempts.
  */
-function toOutputFormatSchema(node) {
+function toAnthropicStrictSchema(node) {
     if (Array.isArray(node))
-        return node.map(toOutputFormatSchema);
+        return node.map(toAnthropicStrictSchema);
     if (node === null || typeof node !== 'object')
         return node;
     const out = {};
     for (const [key, value] of Object.entries(node)) {
-        if (UNSUPPORTED_FORMAT_KEYWORDS.includes(key))
+        if (UNSUPPORTED_STRICT_KEYWORDS.includes(key))
             continue;
         if (key === 'minItems' && typeof value === 'number' && value > 1)
             continue;
@@ -46,10 +49,10 @@ function toOutputFormatSchema(node) {
         // property that happens to be named `minimum` is kept.
         if ((key === 'properties' || key === '$defs' || key === 'definitions')
             && value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            out[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toOutputFormatSchema(v)]));
+            out[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toAnthropicStrictSchema(v)]));
             continue;
         }
-        out[key] = toOutputFormatSchema(value);
+        out[key] = toAnthropicStrictSchema(value);
     }
     const type = out.type;
     if (type === 'object' || (Array.isArray(type) && type.includes('object'))) {
@@ -87,20 +90,25 @@ export const anthropicProvider = {
                 ? [{ type: 'text', text: request.systemPrompt, cache_control: { type: 'ephemeral' } }]
                 : request.systemPrompt;
         }
-        // JSON schema: a forced tool_use call where the model allows it, else
-        // structured outputs (Opus 5.5 rejects forced tool_choice).
+        // JSON schema: a forced, strict tool_use call where the model allows it,
+        // else structured outputs (Opus 5.5 rejects forced tool_choice). Both
+        // constrain decoding to the schema. A tool without `strict: true` is not
+        // enforced: Sonnet 5 returned an array property as a JSON string (digest,
+        // 2026-10-06), Opus 4.8 one wrapped in leaked tool-call markup (podcasts,
+        // 2026-09-15).
         const useOutputFormat = request.jsonSchema !== undefined && !request.supportsForcedToolChoice;
         if (request.jsonSchema && useOutputFormat) {
             body.output_config = {
                 ...body.output_config,
-                format: { type: 'json_schema', schema: toOutputFormatSchema(request.jsonSchema.schema) },
+                format: { type: 'json_schema', schema: toAnthropicStrictSchema(request.jsonSchema.schema) },
             };
         }
         else if (request.jsonSchema) {
             body.tools = [{
                     name: request.jsonSchema.name,
                     description: `Generate structured output matching the ${request.jsonSchema.name} schema`,
-                    input_schema: request.jsonSchema.schema,
+                    input_schema: toAnthropicStrictSchema(request.jsonSchema.schema),
+                    strict: true,
                 }];
             body.tool_choice = { type: 'tool', name: request.jsonSchema.name };
         }

package/dist/llm/providers/openai.js

@@ -37,10 +37,10 @@ function makeNullable(propSchema) {
  * Transform a portable JSON schema into the shape OpenAI's strict Structured
  * Outputs mode requires: every object must set `additionalProperties: false`
  * and list ALL of its properties in `required`. Callers author one portable
- * schema (which also works on Anthropic's tool_use and Gemini's responseSchema,
- * both of which tolerate missing `additionalProperties` and optional fields);
- * this keeps the OpenAI-specific dialect local to this adapter, mirroring the
- * Gemini adapter's own `stripUnsupportedSchemaFields`. Returns a deep copy — the
+ * schema; this keeps the OpenAI-specific dialect local to this adapter,
+ * mirroring the Gemini adapter's `stripUnsupportedSchemaFields` and the
+ * Anthropic adapter's `toAnthropicStrictSchema` (which closes objects but keeps
+ * optional fields optional). Returns a deep copy — the
  * caller's schema object is never mutated (it is reused across failover attempts).
  */
 function toStrictSchema(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.29.0",
+  "version": "3.30.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",