@juspay/neurolink 12.14.13 → 12.14.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.14.13",
+  "version": "12.14.15",
   "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": {
@@ -95,6 +95,7 @@
     "test:proxy-sharing": "pnpm run build && pnpm exec tsx test/continuous-test-suite-proxy-sharing.ts",
     "test:openai-compat-streaming-retry": "pnpm exec tsx test/continuous-test-suite-openai-compat-streaming-retry.ts",
     "test:anthropic-streaming-retry": "pnpm exec tsx test/continuous-test-suite-anthropic-streaming-retry.ts",
+    "test:anthropic-silent-truncation": "pnpm exec tsx test/continuous-test-suite-anthropic-silent-truncation.ts",
     "test:adjust-body-after-400": "pnpm exec tsx test/continuous-test-suite-adjust-body-after-400.ts",
     "test:zod3-schema-native-path": "pnpm exec tsx test/continuous-test-suite-zod3-schema-native-path.ts",
     "test:error-classification-e2e": "pnpm exec tsx test/continuous-test-suite-error-classification-e2e.ts",

package/scripts/observability/docker-compose.proxy-observability.yaml

@@ -18,6 +18,7 @@ services:
       NEUROLINK_PROXY_STREAM_HEADER: ${NEUROLINK_PROXY_STREAM_HEADER:-neurolink-proxy}
     volumes:
       - ./otel-collector.proxy-observability.yaml:/etc/otelcol/config.yaml:ro
+      - otel-collector-data:/var/lib/otelcol
     ports:
       - "${NEUROLINK_OTLP_GRPC_PORT:-14317}:4317"
       - "${NEUROLINK_OTLP_HTTP_PORT:-14318}:4318"
@@ -41,6 +42,7 @@ services:
       ZO_DATA_DIR: /data
       RUST_LOG: ${NEUROLINK_OPENOBSERVE_LOG_LEVEL:-info}
       ZO_INGEST_ALLOWED_UPTO: ${NEUROLINK_OPENOBSERVE_INGEST_HOURS:-720}
+      ZO_COMPACT_DATA_RETENTION_DAYS: ${NEUROLINK_OPENOBSERVE_RETENTION_DAYS:-30}
     volumes:
       - openobserve-data:/data
     networks:
@@ -51,5 +53,7 @@ networks:
     driver: bridge
 
 volumes:
+  otel-collector-data:
+    name: ${NEUROLINK_OTEL_COLLECTOR_VOLUME_NAME:-neurolink-otel-collector-data}
   openobserve-data:
     name: ${NEUROLINK_OPENOBSERVE_VOLUME_NAME:-neurolink-openobserve-data}

package/scripts/observability/otel-collector.proxy-observability.yaml

@@ -38,8 +38,26 @@ exporters:
       stream-name: ${env:NEUROLINK_PROXY_STREAM_HEADER}
     tls:
       insecure: true
+    retry_on_failure:
+      enabled: true
+      initial_interval: 1s
+      max_interval: 30s
+      max_elapsed_time: 0s
+    sending_queue:
+      enabled: true
+      num_consumers: 4
+      queue_size: 4096
+      storage: file_storage
 
 extensions:
+  file_storage:
+    directory: /var/lib/otelcol/storage
+    create_directory: true
+    compaction:
+      directory: /var/lib/otelcol/compaction
+      on_start: true
+      on_rebound: true
+
   health_check:
     endpoint: 0.0.0.0:13133
 
@@ -47,7 +65,7 @@ extensions:
     endpoint: 0.0.0.0:1777
 
 service:
-  extensions: [health_check, pprof]
+  extensions: [file_storage, health_check, pprof]
 
   pipelines:
     traces:

package/scripts/observability/proxy-observability.env.example

@@ -17,6 +17,10 @@ NEUROLINK_OTEL_PPROF_PORT=11777
 # Optional names if you want multiple local stacks in parallel.
 # NEUROLINK_OBSERVABILITY_PROJECT_NAME=neurolink-proxy-observability
 # NEUROLINK_OPENOBSERVE_VOLUME_NAME=neurolink-openobserve-data
+# NEUROLINK_OTEL_COLLECTOR_VOLUME_NAME=neurolink-otel-collector-data
+
+# Bound local telemetry storage while retaining enough incident history.
+NEUROLINK_OPENOBSERVE_RETENTION_DAYS=30
 
 # The collector exports proxy telemetry into this OpenObserve stream header.
 # OpenObserve normalizes the logs and traces stream name to "neurolink_proxy".

package/scripts/observability/proxy-telemetry-check.mjs

@@ -112,30 +112,6 @@ export async function checkProxyTelemetry({
       failureHistoryEvicted: q.failureHistoryEvicted,
     }),
   );
-  add(
-    "producer_delivery",
-    ["metadata", "bodies"].every((kind) =>
-      failures.some((q) => q.kind === kind),
-    ) &&
-      failures.every(
-        (q) =>
-          q.dropped === 0 &&
-          q.exportUnconfirmed === 0 &&
-          q.outstanding < q.capacity,
-      )
-      ? "pass"
-      : "warn",
-    failures,
-  );
-  add(
-    "capture_admission",
-    logs?.bodyCapture &&
-      logs.bodyCapture.rejected === 0 &&
-      logs.bodyCapture.failed === 0
-      ? "pass"
-      : "warn",
-    logs?.bodyCapture ?? { status: "unavailable" },
-  );
   for (const [signal, table] of [
     ["logs", backend.stream],
     ["traces", backend.stream],
@@ -165,13 +141,24 @@ export async function checkProxyTelemetry({
   }
   /** @type {Record<string, import("../../src/lib/types/index.js").ProxyTelemetryStoredRecord[]>} */
   const history = Object.create(null);
-  for (const kind of ["request_final", "body_capture_index", "lifecycle"]) {
+  for (const kind of [
+    "request_final",
+    "body_capture_index",
+    "lifecycle",
+    "telemetry_delivery",
+  ]) {
     const result = await queryProxyHistory({
       ...backend,
       // Capture publication is asynchronous. Include its bounded settling
       // window, and a request-start margin, when reconciling phases to finals.
-      startTime: kind === "body_capture_index" ? Math.max(0, startTime - 120e6) : startTime,
-      endTime: kind === "body_capture_index" ? Math.min(Date.now() * 1000, endTime + 120e6) : endTime,
+      startTime:
+        kind === "body_capture_index"
+          ? Math.max(0, startTime - 120e6)
+          : startTime,
+      endTime:
+        kind === "body_capture_index" || kind === "telemetry_delivery"
+          ? Math.min(Date.now() * 1000, endTime + 120e6)
+          : endTime,
       kind,
       maxRows,
       fetchImpl,
@@ -186,13 +173,143 @@ export async function checkProxyTelemetry({
       if (
         !value ||
         typeof value !== "object" ||
-        typeof value.requestId !== "string"
+        (kind === "telemetry_delivery"
+          ? typeof value.id !== "string" ||
+            typeof value.at !== "string" ||
+            !Number.isFinite(Date.parse(value.at))
+          : typeof value.requestId !== "string")
       ) {
         throw new Error("Stored telemetry metadata has an invalid schema");
       }
       return { ...value, recordedAtMicroseconds: Number(row._timestamp) };
     });
   }
+  /** @param {{at?: unknown}} row */
+  const failedInsideInterval = (row) => {
+    const at = Date.parse(typeof row.at === "string" ? row.at : "");
+    return (
+      Number.isFinite(at) &&
+      at * 1000 >= startTime &&
+      at * 1000 < endTime
+    );
+  };
+  const storedDeliveryFailures = history.telemetry_delivery.filter(
+    failedInsideInterval,
+  );
+  const runtimeDeliveryFailures = failures.flatMap((queue) =>
+    Array.isArray(queue.recentFailures)
+      ? queue.recentFailures.filter(
+          (failure) =>
+            failure &&
+            typeof failure === "object" &&
+            failedInsideInterval(failure),
+        )
+      : [],
+  );
+  const deliveryFailures = [
+    ...new Map(
+      [...storedDeliveryFailures, ...runtimeDeliveryFailures].map(
+        (failure, index) => [
+          typeof failure.id === "string"
+            ? failure.id
+            : `unidentified-${index}`,
+          failure,
+        ],
+      ),
+    ).values(),
+  ];
+  const currentProducerPressure = failures.some(
+    (queue) => queue.outstanding >= queue.capacity,
+  );
+  const runtimeFailureHistoryIncomplete = failures.some((queue) => {
+    if (!(Number(queue.failureHistoryEvicted) > 0)) {
+      return false;
+    }
+    if (!Array.isArray(queue.recentFailures) || !queue.recentFailures.length) {
+      return true;
+    }
+    const oldestRetainedFailure = Math.min(
+      ...queue.recentFailures.map((failure) =>
+        Date.parse(typeof failure?.at === "string" ? failure.at : ""),
+      ),
+    );
+    // The bounded runtime buffer proves absence only from its oldest retained
+    // failure onward. Older selected windows need stored recovery diagnostics;
+    // if those are missing, report uncertainty instead of a false pass.
+    return (
+      !Number.isFinite(oldestRetainedFailure) ||
+      startTime < oldestRetainedFailure * 1000
+    );
+  });
+  add(
+    "producer_delivery",
+    !["metadata", "bodies"].every((kind) =>
+      failures.some((queue) => queue.kind === kind),
+    )
+      ? "unverified"
+      : currentProducerPressure || deliveryFailures.length
+        ? "warn"
+        : runtimeFailureHistoryIncomplete
+          ? "unverified"
+          : "pass",
+    {
+      scope: "selected_interval",
+      deliveryFailures: deliveryFailures.length,
+      failureIds: deliveryFailures.slice(0, 50).map((row) => row.id),
+      sources: {
+        storedRecoveryDiagnostics: storedDeliveryFailures.length,
+        runtimeRecentFailures: runtimeDeliveryFailures.length,
+      },
+      currentPressure: currentProducerPressure,
+      runtimeFailureHistoryComplete: !runtimeFailureHistoryIncomplete,
+      workerLifetime: {
+        scope: "worker_lifetime",
+        queues: failures,
+      },
+    },
+  );
+  const captureIndexes = history.body_capture_index.filter((row) => {
+    const eventTime = Date.parse(
+      typeof row.timestamp === "string" ? row.timestamp : "",
+    );
+    const atMicroseconds = Number.isFinite(eventTime)
+      ? eventTime * 1000
+      : row.recordedAtMicroseconds;
+    return (
+      Number.isFinite(atMicroseconds) &&
+      (atMicroseconds ?? 0) >= startTime &&
+      (atMicroseconds ?? Infinity) < endTime
+    );
+  });
+  const unhealthyCaptures = captureIndexes.filter(
+    (row) =>
+      row.captureError !== undefined ||
+      ![
+        "transport_acknowledged",
+        "no_body",
+        "policy_excluded",
+      ].includes(row.bodyDelivery?.status ?? ""),
+  );
+  add(
+    "capture_admission",
+    !captureIndexes.length
+      ? "unverified"
+      : unhealthyCaptures.length
+        ? "warn"
+        : "pass",
+    {
+      scope: "selected_interval",
+      captures: captureIndexes.length,
+      unhealthy: unhealthyCaptures.length,
+      requestIds: unhealthyCaptures
+        .slice(0, 50)
+        .map((row) => row.requestId),
+      workerLifetime: {
+        scope: "worker_lifetime",
+        counters: logs?.bodyCapture ?? { status: "unavailable" },
+      },
+    },
+  );
   const finals = history.request_final,
     unique = new Set(finals.map((r) => r.requestId));
   add(