@juspay/neurolink 12.14.2 → 12.14.4

package/dist/mcp/caching/toolCache.d.ts

@@ -38,10 +38,18 @@ export declare class ToolCache<T = unknown> extends EventEmitter {
     constructor(config: McpCacheConfig);
     /**
      * Get a value from the cache
+     *
+     * Returns an isolated copy of the stored value (see `cloneCachedValue`), so
+     * a caller mutating what it gets back cannot corrupt the entry for later
+     * hits or for other concurrent callers of the same key.
      */
     get(key: string): T | undefined;
     /**
      * Set a value in the cache
+     *
+     * Stores an isolated copy of `value` (see `cloneCachedValue`), so mutating
+     * the caller's original object after this call cannot reach into the
+     * cache entry.
      */
     set(key: string, value: T, ttl?: number): void;
     /**
@@ -89,6 +97,28 @@ export declare class ToolCache<T = unknown> extends EventEmitter {
      * Stop the auto-cleanup timer
      */
     destroy(): void;
+    /**
+     * Isolate a value crossing the cache boundary (on write into the entry,
+     * and on read back out of it) so no two callers — nor a caller and the
+     * stored entry itself — ever share object identity.
+     *
+     * Without this, `set()` stored the caller's object by reference and
+     * `get()` returned `entry.value` by the same reference on every hit: one
+     * caller mutating a result it got back (e.g. an in-place truncation or
+     * normalization pass) silently corrupted the entry for every later
+     * caller of the same key for the rest of the TTL.
+     *
+     * `structuredClone` is the primary path — it is a deep copy, has no
+     * caller-visible side effects, and (unlike a JSON round-trip) tolerates
+     * circular references, which a sufficiently deep or recursive tool
+     * result could contain. It throws on values it cannot clone (functions,
+     * some non-plain class instances); the JSON round-trip fallback covers
+     * that case for the plain-data shapes MCP tool results actually have
+     * (text/JSON content arrays), at the cost of silently dropping
+     * `undefined`, functions and symbol keys — acceptable for a cache that
+     * only ever holds serializable tool results.
+     */
+    private cloneCachedValue;
     private getFullKey;
     private isExpired;
     /**

package/dist/mcp/caching/toolCache.js

@@ -60,6 +60,10 @@ export class ToolCache extends EventEmitter {
     }
     /**
      * Get a value from the cache
+     *
+     * Returns an isolated copy of the stored value (see `cloneCachedValue`), so
+     * a caller mutating what it gets back cannot corrupt the entry for later
+     * hits or for other concurrent callers of the same key.
      */
     get(key) {
         const fullKey = this.getFullKey(key);
@@ -83,11 +87,24 @@ export class ToolCache extends EventEmitter {
         entry.accessCount++;
         this.stats.hits++;
         this.updateHitRate();
-        this.emit("hit", { key: fullKey, value: entry.value });
-        return entry.value;
+        const returnedValue = this.cloneCachedValue(entry.value);
+        if (this.listenerCount("hit") > 0) {
+            // Listeners get their own copy. `emit` is synchronous, so a listener
+            // that mutates `event.value` would otherwise be mutating the very object
+            // the caller is about to receive.
+            this.emit("hit", {
+                key: fullKey,
+                value: this.cloneCachedValue(entry.value),
+            });
+        }
+        return returnedValue;
     }
     /**
      * Set a value in the cache
+     *
+     * Stores an isolated copy of `value` (see `cloneCachedValue`), so mutating
+     * the caller's original object after this call cannot reach into the
+     * cache entry.
      */
     set(key, value, ttl) {
         const fullKey = this.getFullKey(key);
@@ -98,7 +115,7 @@ export class ToolCache extends EventEmitter {
             this.evictOne();
         }
         const entry = {
-            value,
+            value: this.cloneCachedValue(value),
             expires: now + effectiveTtl,
             createdAt: now,
             accessedAt: now,
@@ -250,6 +267,38 @@ export class ToolCache extends EventEmitter {
         this.clear();
     }
     // ==================== Private Methods ====================
+    /**
+     * Isolate a value crossing the cache boundary (on write into the entry,
+     * and on read back out of it) so no two callers — nor a caller and the
+     * stored entry itself — ever share object identity.
+     *
+     * Without this, `set()` stored the caller's object by reference and
+     * `get()` returned `entry.value` by the same reference on every hit: one
+     * caller mutating a result it got back (e.g. an in-place truncation or
+     * normalization pass) silently corrupted the entry for every later
+     * caller of the same key for the rest of the TTL.
+     *
+     * `structuredClone` is the primary path — it is a deep copy, has no
+     * caller-visible side effects, and (unlike a JSON round-trip) tolerates
+     * circular references, which a sufficiently deep or recursive tool
+     * result could contain. It throws on values it cannot clone (functions,
+     * some non-plain class instances); the JSON round-trip fallback covers
+     * that case for the plain-data shapes MCP tool results actually have
+     * (text/JSON content arrays), at the cost of silently dropping
+     * `undefined`, functions and symbol keys — acceptable for a cache that
+     * only ever holds serializable tool results.
+     */
+    cloneCachedValue(value) {
+        if (value === null || typeof value !== "object") {
+            return value;
+        }
+        try {
+            return structuredClone(value);
+        }
+        catch {
+            return JSON.parse(JSON.stringify(value));
+        }
+    }
     getFullKey(key) {
         return this.config.namespace ? `${this.config.namespace}:${key}` : key;
     }

package/dist/providers/openaiChatCompletionsClient.js

@@ -387,6 +387,118 @@ export const v3ToolChoiceToOpenAI = (choice, toolNameToWire) => {
             };
     }
 };
+/**
+ * OpenAI's strict structured-output mode rejects a schema unless every object
+ * node carries `additionalProperties: false` AND lists every one of its
+ * properties in `required` — recursively, including through array `items`.
+ * A plain JSON Schema satisfies neither, so sending one with `strict: true`
+ * fails the request outright rather than degrading.
+ *
+ * Adding `additionalProperties: false` is safe: it forbids keys the caller
+ * never asked for, which strict mode would forbid anyway. Filling in
+ * `required` is NOT safe — it would silently make the caller's optional
+ * fields mandatory. So when a schema still has optional properties after
+ * normalisation, the request drops to `strict: false`, which OpenAI accepts
+ * and which honours optionality. Callers whose schemas are already strict-
+ * compatible keep the stronger guarantee.
+ */
+// `properties` and `$defs` are MAPS of schemas, not schemas — recursing into
+// them as if they were nodes silently skips every child, which is exactly the
+// bug that let a nested object through without `additionalProperties: false`.
+const SCHEMA_MAPS = [
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+];
+const SCHEMA_NODES = [
+    "items",
+    "prefixItems",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "not",
+    "then",
+    "else",
+];
+// OpenAI's strict mode does not accept these composition keywords. A schema
+// carrying one cannot be sent with `strict: true` at all, so it is not merely
+// "not yet normalised" — it must drop to non-strict, where the schema is
+// honoured as written.
+const STRICT_UNSUPPORTED = ["allOf", "not", "if", "then", "else"];
+const mapValues = (obj, fn) => Object.fromEntries(Object.entries((obj ?? {})).map(([k, v]) => [
+    k,
+    fn(v),
+]));
+const withClosedObjects = (node) => {
+    if (Array.isArray(node)) {
+        return node.map(withClosedObjects);
+    }
+    if (!node || typeof node !== "object") {
+        return node;
+    }
+    const next = {
+        ...node,
+    };
+    for (const key of SCHEMA_MAPS) {
+        if (key in next) {
+            next[key] = mapValues(next[key], withClosedObjects);
+        }
+    }
+    for (const key of SCHEMA_NODES) {
+        if (key in next) {
+            next[key] = withClosedObjects(next[key]);
+        }
+    }
+    // A schema-valued `additionalProperties` is itself a schema (the index/value
+    // pattern) and its nested objects need closing too. A boolean one is a flag
+    // and must be left exactly as the caller wrote it.
+    if (next.additionalProperties &&
+        typeof next.additionalProperties === "object") {
+        next.additionalProperties = withClosedObjects(next.additionalProperties);
+    }
+    else if (next.type === "object" && !("additionalProperties" in next)) {
+        // Closed whether or not it declares `properties`: strict mode requires the
+        // key on EVERY object, including an empty one.
+        next.additionalProperties = false;
+    }
+    return next;
+};
+/**
+ * True when the schema can legally be sent with `strict: true`: every object
+ * node lists all of its properties as required, every object is closed, and
+ * no composition keyword OpenAI rejects appears anywhere.
+ *
+ * Deliberately conservative — a false negative costs only the stronger
+ * guarantee, while a false positive costs the whole request.
+ */
+const satisfiesStrictRequired = (node) => {
+    if (Array.isArray(node)) {
+        return node.every(satisfiesStrictRequired);
+    }
+    if (!node || typeof node !== "object") {
+        return true;
+    }
+    const rec = node;
+    if (STRICT_UNSUPPORTED.some((k) => k in rec)) {
+        return false;
+    }
+    if (rec.type === "object") {
+        if (rec.additionalProperties !== false) {
+            return false;
+        }
+        const names = Object.keys((rec.properties ?? {}));
+        const required = Array.isArray(rec.required)
+            ? rec.required
+            : [];
+        if (names.some((n) => !required.includes(n))) {
+            return false;
+        }
+    }
+    const mapsOk = SCHEMA_MAPS.filter((k) => k in rec).every((k) => Object.values((rec[k] ?? {})).every(satisfiesStrictRequired));
+    const nodesOk = SCHEMA_NODES.filter((k) => k in rec).every((k) => satisfiesStrictRequired(rec[k]));
+    return mapsOk && nodesOk;
+};
 export const v3ResponseFormatToOpenAI = (rf) => {
     if (rf.type === "text") {
         return { type: "text" };
@@ -394,13 +506,38 @@ export const v3ResponseFormatToOpenAI = (rf) => {
     if (!rf.schema) {
         return { type: "json_object" };
     }
+    // Mutate as little as possible, in this order:
+    //
+    //   1. already strict-legal  -> send it UNTOUCHED with strict: true
+    //   2. legal once closed     -> send the closed copy with strict: true
+    //   3. neither               -> send it UNTOUCHED with strict: false
+    //
+    // Case 3 is why closure is not applied unconditionally. Non-strict mode
+    // honours the schema exactly as written, so injecting
+    // `additionalProperties: false` there would silently change the caller's
+    // contract — and for a composition it can make the schema unsatisfiable:
+    // closing two `allOf` members that declare different properties leaves no
+    // object able to satisfy both. Leaving case 3 untouched also means
+    // non-OpenAI endpoints in this family, which may not implement OpenAI's
+    // strict contract at all, see exactly the schema the caller wrote.
+    //
+    // Case 1 matters for parity: a Zod schema whose properties are all required
+    // already converts to a strict-legal shape, so it goes out byte-identical to
+    // what it did before this change.
+    const original = rf.schema;
+    const closed = withClosedObjects(original);
+    const schema = satisfiesStrictRequired(original)
+        ? original
+        : satisfiesStrictRequired(closed)
+            ? closed
+            : original;
     return {
         type: "json_schema",
         json_schema: {
             name: rf.name ?? "response",
-            schema: rf.schema,
+            schema: schema,
             ...(rf.description ? { description: rf.description } : {}),
-            strict: true,
+            strict: satisfiesStrictRequired(schema),
         },
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.14.2",
+  "version": "12.14.4",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {