open-agents-ai 0.187.345 → 0.187.346

package/dist/index.js

@@ -269122,6 +269122,319 @@ var init_proceduralMemoryStore = __esm({
   }
 });
 
+// packages/memory/dist/splanifold.js
+function h00(t2) {
+  return 2 * t2 * t2 * t2 - 3 * t2 * t2 + 1;
+}
+function h01(t2) {
+  return -2 * t2 * t2 * t2 + 3 * t2 * t2;
+}
+function h10(t2) {
+  return t2 * (t2 - 1) * (t2 - 1);
+}
+function h11(t2) {
+  return t2 * t2 * (t2 - 1);
+}
+function evaluate(controls, r2) {
+  const { K: K2, N, P: P2, E: Eb, Pd, Ed, expansion, epsSigma, deltaMax } = controls;
+  const eps2 = epsSigma * epsSigma;
+  const u = new Float64Array(K2);
+  const scale = 1 + 2 * expansion;
+  for (let k = 0; k < K2; k++) {
+    u[k] = scale * r2[k] - expansion;
+  }
+  let sigma = 0;
+  for (let k = 0; k < K2; k++)
+    sigma += u[k];
+  const t2 = sigma / K2;
+  const delta = new Float64Array(K2);
+  for (let k = 0; k < K2; k++)
+    delta[k] = u[k] - t2;
+  let deltaTilde = delta;
+  if (isFinite(deltaMax)) {
+    const normSq = delta.reduce((s2, d2) => s2 + d2 * d2, 0);
+    const norm = Math.sqrt(normSq);
+    if (norm > 0) {
+      const warpScale = 1 / Math.sqrt(1 + (norm / deltaMax) ** 2);
+      deltaTilde = new Float64Array(K2);
+      for (let k = 0; k < K2; k++)
+        deltaTilde[k] = delta[k] * warpScale;
+    }
+  }
+  const w = new Float64Array(K2);
+  const denom = sigma * sigma + eps2;
+  for (let k = 0; k < K2; k++) {
+    w[k] = (sigma * u[k] + eps2 / K2) / denom;
+  }
+  const V0 = matVecColMajor(Pd[0], N, K2, w);
+  const V1 = matVecColMajor(Pd[1], N, K2, w);
+  const spine = hermite(P2[0], P2[1], V0, V1, t2, N);
+  const D0 = matVecColMajor(Eb[0], N, K2, deltaTilde);
+  const D1 = matVecColMajor(Eb[1], N, K2, deltaTilde);
+  const T0 = matVecColMajor(Ed[0], N, K2, deltaTilde);
+  const T1 = matVecColMajor(Ed[1], N, K2, deltaTilde);
+  const trans = hermite(D0, D1, T0, T1, t2, N);
+  const out = new Float64Array(N);
+  for (let n2 = 0; n2 < N; n2++)
+    out[n2] = spine[n2] + trans[n2];
+  return out;
+}
+function hermite(A, B, Ad, Bd, t2, N) {
+  const h0 = h00(t2), h1 = h01(t2), d0 = h10(t2), d1 = h11(t2);
+  const out = new Float64Array(N);
+  for (let n2 = 0; n2 < N; n2++) {
+    out[n2] = h0 * A[n2] + h1 * B[n2] + d0 * Ad[n2] + d1 * Bd[n2];
+  }
+  return out;
+}
+function matVecColMajor(M, N, K2, x) {
+  const y = new Float64Array(N);
+  for (let k = 0; k < K2; k++) {
+    const xk = x[k];
+    const offset = k * N;
+    for (let n2 = 0; n2 < N; n2++) {
+      y[n2] += M[offset + n2] * xk;
+    }
+  }
+  return y;
+}
+function fit(samples, K2, N, config) {
+  const expansion = config?.expansion ?? 0;
+  const epsSigma = config?.epsSigma ?? 0.02;
+  const deltaMax = config?.deltaMax ?? Infinity;
+  const lambda = config?.ridgeLambda ?? 1e-4;
+  const eps2 = epsSigma * epsSigma;
+  const S = samples.length;
+  const cols = 2 + 6 * K2;
+  const F = new Float64Array(cols * S);
+  const X = new Float64Array(N * S);
+  const scale = 1 + 2 * expansion;
+  for (let j = 0; j < S; j++) {
+    const r2 = samples[j].input;
+    const x = samples[j].output;
+    const u = new Float64Array(K2);
+    for (let k = 0; k < K2; k++)
+      u[k] = scale * r2[k] - expansion;
+    let sigma = 0;
+    for (let k = 0; k < K2; k++)
+      sigma += u[k];
+    const t2 = sigma / K2;
+    const deltaTilde = new Float64Array(K2);
+    for (let k = 0; k < K2; k++)
+      deltaTilde[k] = u[k] - t2;
+    if (isFinite(deltaMax)) {
+      const normSq = deltaTilde.reduce((s2, d2) => s2 + d2 * d2, 0);
+      const norm = Math.sqrt(normSq);
+      if (norm > 0) {
+        const warpScale = 1 / Math.sqrt(1 + (norm / deltaMax) ** 2);
+        for (let k = 0; k < K2; k++)
+          deltaTilde[k] *= warpScale;
+      }
+    }
+    const w = new Float64Array(K2);
+    const denom = sigma * sigma + eps2;
+    for (let k = 0; k < K2; k++) {
+      w[k] = (sigma * u[k] + eps2 / K2) / denom;
+    }
+    const a0 = h00(t2), a1 = h01(t2), b0 = h10(t2), b1 = h11(t2);
+    let col2 = 0;
+    F[col2 * S + j] = a0;
+    col2++;
+    F[col2 * S + j] = a1;
+    col2++;
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = b0 * w[k];
+      col2++;
+    }
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = b1 * w[k];
+      col2++;
+    }
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = a0 * deltaTilde[k];
+      col2++;
+    }
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = a1 * deltaTilde[k];
+      col2++;
+    }
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = b0 * deltaTilde[k];
+      col2++;
+    }
+    for (let k = 0; k < K2; k++) {
+      F[col2 * S + j] = b1 * deltaTilde[k];
+      col2++;
+    }
+    for (let n2 = 0; n2 < N; n2++)
+      X[n2 * S + j] = x[n2];
+  }
+  const G = new Float64Array(cols * cols);
+  for (let i2 = 0; i2 < cols; i2++) {
+    for (let jj = i2; jj < cols; jj++) {
+      let dot = 0;
+      for (let s2 = 0; s2 < S; s2++)
+        dot += F[i2 * S + s2] * F[jj * S + s2];
+      G[i2 * cols + jj] = dot;
+      G[jj * cols + i2] = dot;
+    }
+    G[i2 * cols + i2] += lambda;
+  }
+  const Ginv = invertSPD(G, cols);
+  const XFt = new Float64Array(N * cols);
+  for (let n2 = 0; n2 < N; n2++) {
+    for (let c8 = 0; c8 < cols; c8++) {
+      let dot = 0;
+      for (let s2 = 0; s2 < S; s2++)
+        dot += X[n2 * S + s2] * F[c8 * S + s2];
+      XFt[n2 * cols + c8] = dot;
+    }
+  }
+  const C = new Float64Array(N * cols);
+  for (let n2 = 0; n2 < N; n2++) {
+    for (let c8 = 0; c8 < cols; c8++) {
+      let dot = 0;
+      for (let cc = 0; cc < cols; cc++)
+        dot += XFt[n2 * cols + cc] * Ginv[cc * cols + c8];
+      C[n2 * cols + c8] = dot;
+    }
+  }
+  const extractCol = (idx) => {
+    const v = new Float64Array(N);
+    for (let n2 = 0; n2 < N; n2++)
+      v[n2] = C[n2 * cols + idx];
+    return v;
+  };
+  const extractMat = (startCol, numCols) => {
+    const M = new Float64Array(N * numCols);
+    for (let k = 0; k < numCols; k++) {
+      for (let n2 = 0; n2 < N; n2++) {
+        M[k * N + n2] = C[n2 * cols + startCol + k];
+      }
+    }
+    return M;
+  };
+  let col = 0;
+  const P0 = extractCol(col++);
+  const P1 = extractCol(col++);
+  const Pd0 = extractMat(col, K2);
+  col += K2;
+  const Pd1 = extractMat(col, K2);
+  col += K2;
+  const E0 = extractMat(col, K2);
+  col += K2;
+  const E1 = extractMat(col, K2);
+  col += K2;
+  const Ed0 = extractMat(col, K2);
+  col += K2;
+  const Ed1 = extractMat(col, K2);
+  col += K2;
+  return {
+    K: K2,
+    N,
+    P: [P0, P1],
+    E: [E0, E1],
+    Pd: [Pd0, Pd1],
+    Ed: [Ed0, Ed1],
+    expansion,
+    epsSigma,
+    deltaMax
+  };
+}
+function invertSPD(A, n2) {
+  const L = new Float64Array(n2 * n2);
+  for (let i2 = 0; i2 < n2; i2++) {
+    for (let j = 0; j <= i2; j++) {
+      let sum = A[i2 * n2 + j];
+      for (let k = 0; k < j; k++)
+        sum -= L[i2 * n2 + k] * L[j * n2 + k];
+      if (i2 === j) {
+        if (sum <= 0) {
+          const Areg = new Float64Array(A);
+          for (let ii = 0; ii < n2; ii++)
+            Areg[ii * n2 + ii] += 1e-6;
+          return invertSPD(Areg, n2);
+        }
+        L[i2 * n2 + j] = Math.sqrt(sum);
+      } else {
+        L[i2 * n2 + j] = sum / L[j * n2 + j];
+      }
+    }
+  }
+  const Ainv = new Float64Array(n2 * n2);
+  const col = new Float64Array(n2);
+  for (let c8 = 0; c8 < n2; c8++) {
+    col.fill(0);
+    for (let i2 = 0; i2 < n2; i2++) {
+      let sum = i2 === c8 ? 1 : 0;
+      for (let k = 0; k < i2; k++)
+        sum -= L[i2 * n2 + k] * col[k];
+      col[i2] = sum / L[i2 * n2 + i2];
+    }
+    for (let i2 = n2 - 1; i2 >= 0; i2--) {
+      let sum = col[i2];
+      for (let k = i2 + 1; k < n2; k++)
+        sum -= L[k * n2 + i2] * col[k];
+      col[i2] = sum / L[i2 * n2 + i2];
+    }
+    for (let i2 = 0; i2 < n2; i2++)
+      Ainv[i2 * n2 + c8] = col[i2];
+  }
+  return Ainv;
+}
+function serialize(controls) {
+  return {
+    K: controls.K,
+    N: controls.N,
+    P: [Array.from(controls.P[0]), Array.from(controls.P[1])],
+    E: [Array.from(controls.E[0]), Array.from(controls.E[1])],
+    Pd: [Array.from(controls.Pd[0]), Array.from(controls.Pd[1])],
+    Ed: [Array.from(controls.Ed[0]), Array.from(controls.Ed[1])],
+    expansion: controls.expansion,
+    epsSigma: controls.epsSigma,
+    deltaMax: controls.deltaMax
+  };
+}
+function deserialize(obj) {
+  return {
+    K: obj.K,
+    N: obj.N,
+    P: [obj.P[0], obj.P[1]].map((a2) => new Float64Array(a2)),
+    E: [obj.E[0], obj.E[1]].map((a2) => new Float64Array(a2)),
+    Pd: [obj.Pd[0], obj.Pd[1]].map((a2) => new Float64Array(a2)),
+    Ed: [obj.Ed[0], obj.Ed[1]].map((a2) => new Float64Array(a2)),
+    expansion: obj.expansion,
+    epsSigma: obj.epsSigma,
+    deltaMax: obj.deltaMax
+  };
+}
+function rmse(controls, samples) {
+  let sumSq = 0;
+  for (const s2 of samples) {
+    const pred = evaluate(controls, s2.input);
+    for (let n2 = 0; n2 < controls.N; n2++) {
+      const diff = pred[n2] - s2.output[n2];
+      sumSq += diff * diff;
+    }
+  }
+  return Math.sqrt(sumSq / (samples.length * controls.N));
+}
+function cosine(a2, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i2 = 0; i2 < a2.length; i2++) {
+    dot += a2[i2] * b[i2];
+    na += a2[i2] * a2[i2];
+    nb += b[i2] * b[i2];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom > 0 ? dot / denom : 0;
+}
+var init_splanifold = __esm({
+  "packages/memory/dist/splanifold.js"() {
+    "use strict";
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports3 = {};
 __export(dist_exports3, {
@@ -269151,7 +269464,13 @@ __export(dist_exports3, {
   initDb: () => initDb,
   linkEpisode: () => linkEpisode,
   personalizedPageRank: () => personalizedPageRank,
-  retrieveByPPR: () => retrieveByPPR
+  retrieveByPPR: () => retrieveByPPR,
+  splanifoldCosine: () => cosine,
+  splanifoldDeserialize: () => deserialize,
+  splanifoldEvaluate: () => evaluate,
+  splanifoldFit: () => fit,
+  splanifoldRmse: () => rmse,
+  splanifoldSerialize: () => serialize
 });
 var init_dist7 = __esm({
   "packages/memory/dist/index.js"() {
@@ -269171,6 +269490,7 @@ var init_dist7 = __esm({
     init_pprRetrieval();
     init_embeddings();
     init_proceduralMemoryStore();
+    init_splanifold();
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.345",
+  "version": "0.187.346",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) \u2014 interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",