@feniix/bridgekit 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -4,7 +4,21 @@ All notable changes to `@feniix/bridgekit` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.8.2] - Unreleased
+## [0.8.3] - Unreleased
+
+### Fixed
+
+- `PortableValidationError.field` now preserves the full property name when
+  it contains `/`. TypeBox does not implement JSON Pointer RFC 6901's `~1`
+  escape, so a property named `a/b` previously produced `field: "b"` for
+  wrong-type / `const` / `enum` errors (the string-split fallback dropped
+  the prefix). The fix walks the actual schema with a greedy longest-prefix
+  match against `properties` keys and falls back to the prior behavior for
+  paths the schema doesn't model. The `required` and `additionalProperties`
+  paths were already correct via structured `params` and are unchanged.
+  Resolves [#36](https://github.com/feniix/bridgekit/issues/36).
+
+## [0.8.2] - 2026-05-26
 
 ### Fixed
 

package/dist/src/core/execute-tool.js

@@ -3,6 +3,82 @@ const ROOT_FIELD = "(root)";
 function fieldFromPath(instancePath) {
     return instancePath.split("/").filter(Boolean).at(-1) ?? ROOT_FIELD;
 }
+/**
+ * Resolve the leaf field name of an instancePath against the actual schema.
+ *
+ * TypeBox does not escape `/` inside property names when building
+ * `instancePath` (it does not follow JSON Pointer RFC 6901's `~1` encoding),
+ * so a property literally named `a/b` produces `instancePath: "/a/b"`. The
+ * string-split fallback (`fieldFromPath`) would then surface `"b"` and lose
+ * the prefix. This helper walks the schema greedily — at each object node it
+ * matches the longest prefix of remaining path segments that names a real
+ * property key, descending into the matched sub-schema — and returns the
+ * actual leaf key. Array nodes consume a single numeric segment via `items`.
+ *
+ * Returns `undefined` if the walk gets stuck (the schema does not model the
+ * data path — e.g. `additionalProperties` content). The caller then falls
+ * back to the string-split `fieldFromPath`, preserving prior behavior.
+ *
+ * The `required` and `additionalProperties` callers already read structured
+ * `params` and are unaffected; this helper covers the `const` / `enum` /
+ * default keyword branches.
+ */
+function fieldFromSchemaWalk(schema, instancePath) {
+    if (instancePath === "")
+        return undefined;
+    const segments = instancePath.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return undefined;
+    let current = schema;
+    let lastKey;
+    let i = 0;
+    while (i < segments.length) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        const node = current;
+        // Array descent: numeric segment against an `items` schema. Tuple-form
+        // `items` (array) indexes positionally; schema-form descends uniformly.
+        if (node.items !== undefined && /^\d+$/.test(segments[i])) {
+            const idx = Number(segments[i]);
+            if (Array.isArray(node.items)) {
+                if (idx >= node.items.length)
+                    return undefined;
+                current = node.items[idx];
+            }
+            else {
+                current = node.items;
+            }
+            lastKey = segments[i];
+            i++;
+            continue;
+        }
+        // Object descent: greedy longest-prefix match against `properties` keys.
+        // This is what lets `a/b` resolve to a single key when the schema
+        // declares it, even though the instancePath segments it as ["a", "b"].
+        if (node.properties && typeof node.properties === "object") {
+            const props = node.properties;
+            let matched = -1;
+            for (let j = segments.length; j > i; j--) {
+                const candidate = segments.slice(i, j).join("/");
+                if (Object.hasOwn(props, candidate)) {
+                    matched = j;
+                    lastKey = candidate;
+                    current = props[candidate];
+                    break;
+                }
+            }
+            if (matched === -1)
+                return undefined;
+            i = matched;
+            continue;
+        }
+        return undefined;
+    }
+    return lastKey;
+}
+function fieldFromError(schema, error) {
+    return fieldFromSchemaWalk(schema, error.instancePath) ?? fieldFromPath(error.instancePath);
+}
 function readDiscriminatorValues(propSchema) {
     // Extract the allowed values from a discriminator-eligible prop schema.
     // Recognizes three shapes:
@@ -253,7 +329,7 @@ function suppressSiblingErrorsUnderUnion(schema, value, errors) {
         return true;
     });
 }
-function expandTypeBoxError(error) {
+function expandTypeBoxError(schema, error) {
     // Read offending property names from TypeBox's structured `params` rather
     // than parsing the message string. Two payoffs: locale independence (the
     // helper works the same after `Locale.Set("de_DE")`), and faithful
@@ -284,7 +360,7 @@ function expandTypeBoxError(error) {
     if (error.keyword === "const") {
         return [
             {
-                field: fieldFromPath(error.instancePath),
+                field: fieldFromError(schema, error),
                 message: `must equal ${JSON.stringify(error.params.allowedValue)}`,
             },
         ];
@@ -293,12 +369,12 @@ function expandTypeBoxError(error) {
         const allowed = error.params.allowedValues ?? [];
         return [
             {
-                field: fieldFromPath(error.instancePath),
+                field: fieldFromError(schema, error),
                 message: allowed.length > 0 ? `must equal one of ${allowed.map((v) => JSON.stringify(v)).join(", ")}` : error.message,
             },
         ];
     }
-    return [{ field: fieldFromPath(error.instancePath), message: error.message }];
+    return [{ field: fieldFromError(schema, error), message: error.message }];
 }
 export function validatePortableToolArgs(tool, args) {
     if (Check(tool.parameters, args)) {
@@ -316,7 +392,7 @@ export function validatePortableToolArgs(tool, args) {
     ]);
     const seen = new Set();
     const errors = rawErrors
-        .flatMap((error) => expandTypeBoxError(error))
+        .flatMap((error) => expandTypeBoxError(tool.parameters, error))
         .filter(({ field, message }) => {
         const key = JSON.stringify([field, message]);
         if (seen.has(key))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feniix/bridgekit",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "BridgeKit defines TypeBox-backed tools once and adapts them to pi, MCP, and other hosts.",
   "keywords": [
     "pi",