dsh-eval-guard 0.6.1 → 0.7.1

package/assets/neural-pendulum/include/nn/nn.hpp

@@ -0,0 +1,88 @@
+// Neural-CPP public interface. Implement everything declared here.
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace nn {
+
+using Shape = std::vector<int64_t>;
+
+enum class DType : uint8_t {
+    F32, F64,
+    I8, I16, I32, I64, I128,
+    U8, U16, U32, U64, U128,
+    BF16, FP8_E5M2, MXFP4
+};
+
+enum class Rounding : uint8_t { NearestEven, TowardZero, Stochastic };
+enum class ThreadMode : uint8_t { Development, Evaluation };
+
+constexpr int kDevMaxThreads = 4;
+
+std::size_t dtype_size(DType dtype);
+const char* dtype_name(DType dtype);
+
+class Tensor {
+public:
+    Tensor();
+    Tensor(const Tensor&) = default;
+    Tensor(Tensor&&) noexcept = default;
+    Tensor& operator=(const Tensor&) = default;
+    Tensor& operator=(Tensor&&) noexcept = default;
+    ~Tensor();
+
+    static Tensor empty(const Shape& shape, DType dtype);
+    static Tensor from_data(const void* data, const Shape& shape, DType dtype);
+
+    const Shape& shape() const;
+    DType dtype() const;
+    int64_t ndim() const;
+    int64_t numel() const;
+    bool is_contiguous() const;
+
+    const void* data() const;
+    void* data();
+
+    Tensor to(DType dst, Rounding mode = Rounding::NearestEven, uint64_t seed = 0) const;
+    Tensor view(const Shape& shape) const;
+    Tensor reshape(const Shape& shape) const;
+    Tensor permute(const std::vector<int>& dims) const;
+    Tensor slice(int dim, int64_t start, int64_t stop, int64_t step = 1) const;
+    Tensor contiguous() const;
+    Tensor clone() const;
+
+    void set_requires_grad(bool value);
+    bool requires_grad() const;
+    Tensor grad() const;
+    void backward();
+
+    // Implementation detail. Exposed so the library implementer can define
+    // free functions without the header becoming a barrier.
+    struct Impl;
+    std::shared_ptr<Impl> impl_;
+};
+
+Tensor add(const Tensor& a, const Tensor& b);
+Tensor sub(const Tensor& a, const Tensor& b);
+Tensor mul(const Tensor& a, const Tensor& b);
+Tensor div(const Tensor& a, const Tensor& b);
+Tensor sum(const Tensor& a, int dim = -1);
+Tensor mean(const Tensor& a, int dim = -1);
+
+Tensor matmul(const Tensor& a, const Tensor& b);
+Tensor matmul_nd(const Tensor& a, const Tensor& b,
+                 const std::vector<int>& a_batch_dims,
+                 const std::vector<int>& b_batch_dims,
+                 const std::vector<int>& a_matrix_dims,
+                 const std::vector<int>& b_matrix_dims);
+
+void set_thread_mode(ThreadMode mode);
+void set_num_threads(int n);
+int num_threads();
+int active_workers();
+
+}  // namespace nn

package/assets/neural-pendulum/sim.cpp

@@ -0,0 +1,126 @@
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace {
+constexpr int N = 3;
+constexpr double DT = 0.01;
+constexpr int SUB = 4;
+constexpr int MAX_STEPS = 3000;
+constexpr double PI = 3.14159265358979323846;
+constexpr double GRAV = 9.81;
+constexpr double DAMP = 0.01;
+constexpr double TAU_MAX = 18.0;
+const std::array<double, N> MASS{{1.0, 1.0, 1.0}};
+const std::array<double, N> LEN{{0.5, 0.5, 0.5}};
+const std::array<double, N> R{{0.25, 0.25, 0.25}};
+const std::array<double, N> INERTIA{{MASS[0]*LEN[0]*LEN[0]/12.0, MASS[1]*LEN[1]*LEN[1]/12.0, MASS[2]*LEN[2]*LEN[2]/12.0}};
+const std::array<double, N> GCOEF{{MASS[0]*R[0] + LEN[0]*(MASS[1]+MASS[2]),
+                                   MASS[1]*R[1] + LEN[1]*MASS[2],
+                                   MASS[2]*R[2]}};
+
+struct Vec { std::array<double,N> v{}; };
+struct State { std::array<double,N> theta{}; std::array<double,N> omega{}; };
+
+double wrap(double x) {
+  while (x <= -PI) x += 2*PI;
+  while (x > PI) x -= 2*PI;
+  return x;
+}
+
+static std::array<std::array<double,N>,N> mass_matrix(const std::array<double,N>& q) {
+  std::array<std::array<double,N>,N> M{};
+  for (int i=0;i<N;i++) for (int j=0;j<N;j++) {
+    if (i==j) {
+      double tail=0; for (int k=i+1;k<N;k++) tail += MASS[k];
+      M[i][j] = INERTIA[i] + MASS[i]*R[i]*R[i] + LEN[i]*LEN[i]*tail;
+    } else {
+      int a=std::min(i,j), b=std::max(i,j);
+      M[i][j] = LEN[a] * GCOEF[b] * std::cos(q[i]-q[j]);
+    }
+  }
+  return M;
+}
+static void solve3(const std::array<std::array<double,N>,N>& A, const std::array<double,N>& b, std::array<double,N>& x) {
+  double a[3][4];
+  for(int i=0;i<3;i++){ for(int j=0;j<3;j++) a[i][j]=A[i][j]; a[i][3]=b[i]; }
+  for(int c=0;c<3;c++){
+    int p=c; for(int r=c+1;r<3;r++) if(std::fabs(a[r][c])>std::fabs(a[p][c])) p=r;
+    if(p!=c) for(int j=0;j<4;j++) std::swap(a[c][j],a[p][j]);
+    double d=a[c][c]; if(std::fabs(d)<1e-15) d=(d<0?-1e-15:1e-15);
+    for(int j=c;j<4;j++) a[c][j]/=d;
+    for(int r=0;r<3;r++) if(r!=c){ double f=a[r][c]; for(int j=c;j<4;j++) a[r][j]-=f*a[c][j]; }
+  }
+  for(int i=0;i<3;i++) x[i]=a[i][3];
+}
+static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
+  auto M = mass_matrix(s.theta);
+  std::array<double,N> C{}, G{}, Q{}, rhs{};
+  for(int i=0;i<N;i++){
+    double ci=0;
+    for(int j=0;j<N;j++) if(j!=i) ci += M[i][j] * std::sin(s.theta[i]-s.theta[j]) * s.omega[j]*s.omega[j];
+    C[i]=ci;
+    G[i]=GRAV*std::sin(s.theta[i])*GCOEF[i];
+  }
+  // joint damping: b * D^T D omega, D lower bidiagonal with -1 previous
+  for(int i=0;i<N;i++){
+    double e=s.omega[i] - (i>0?s.omega[i-1]:0.0);
+    Q[i] -= DAMP*e;
+  }
+  for(int i=0;i<N;i++) rhs[i]=tau[i]-C[i]-G[i]+Q[i];
+  solve3(M, rhs, out.omega);
+  out.theta = s.omega;
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  bool eval=false; int seed=0;
+  for(int i=1;i<argc;i++){ std::string a=argv[i]; if(a=="--eval") eval=true; else if(a=="--seed" && i+1<argc) seed=std::atoi(argv[++i]); }
+  std::mt19937 rng(seed);
+  std::uniform_real_distribution<double> u(-1.0,1.0);
+  State s;
+  int steps=0; bool ready=false;
+  auto reset=[&](){ steps=0; ready=true; if(eval){ s.theta={0.013,-0.008,0.021}; s.omega={0,0,0}; } else { s.theta={u(rng)*0.05,u(rng)*0.05,u(rng)*0.05}; s.omega={u(rng)*0.02,u(rng)*0.02,u(rng)*0.02}; } };
+  // zero state
+  s.theta={0,0,0}; s.omega={0,0,0};
+  std::string line;
+  while(std::getline(std::cin,line)){
+    if(line.empty()) continue;
+    if(line.find("reset")!=std::string::npos){ reset(); std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush; continue; }
+    if(line.find("step")!=std::string::npos){
+      if(!ready || steps>=MAX_STEPS){ std::cout << "{\"error\":\"episode_finished\"}\n" << std::flush; continue; }
+      // parse torque array
+      double u1=0,u3=0; auto p=line.find('['); if(p!=std::string::npos){ char* end=nullptr; u1=std::strtod(line.c_str()+p+1,&end); if(end){ const char* q=end; while(*q && (*q==','||*q==' ')) q++; u3=std::strtod(q,&end); } }
+      u1=std::max(-1.0,std::min(1.0,u1)); u3=std::max(-1.0,std::min(1.0,u3));
+      std::array<double,N> tau{{u1*TAU_MAX,0.0,u3*TAU_MAX}};
+      // one control step with 4 RK4 substeps
+      double h=DT/SUB;
+      for(int sub=0;sub<SUB;sub++){
+        State k1=s,k2=s,k3=s,k4=s; State d{};
+        deriv(k1,tau,d); for(int i=0;i<N;i++){ k2.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k2.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k2,tau,d); for(int i=0;i<N;i++){ k3.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k3.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k3,tau,d); for(int i=0;i<N;i++){ k4.theta[i]=s.theta[i]+h*d.theta[i]; k4.omega[i]=s.omega[i]+h*d.omega[i]; }
+        deriv(k4,tau,d);
+        // need derivatives at all; use helper recompute arrays
+        State ds1{},ds2{},ds3{},ds4{};
+        deriv(k1,tau,ds1); deriv(k2,tau,ds2); deriv(k3,tau,ds3); deriv(k4,tau,ds4);
+        for(int i=0;i<N;i++){
+          s.theta[i] += h/6.0*(ds1.theta[i]+2*ds2.theta[i]+2*ds3.theta[i]+ds4.theta[i]);
+          s.omega[i] += h/6.0*(ds1.omega[i]+2*ds2.omega[i]+2*ds3.omega[i]+ds4.omega[i]);
+        }
+      }
+      steps++;
+      std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush;
+      continue;
+    }
+    std::cout << "{\"error\":\"bad_command\"}\n" << std::flush;
+  }
+  return 0;
+}

package/eval/neural-pendulum.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Plugin wrapper for the standalone Neural-Pendulum evaluator."""
+from __future__ import annotations
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+STANDALONE = HERE.parent / 'neural-pendulum-eval' / 'run_eval.py'
+
+if not STANDALONE.is_file():
+    print('neural-pendulum-eval/run_eval.py missing; copy the standalone evaluator folder first', file=sys.stderr)
+    raise SystemExit(1)
+
+os.execv(sys.executable, [sys.executable, '-X', 'utf8', str(STANDALONE), *sys.argv[1:]])

package/lib/client/index.js

@@ -94,7 +94,9 @@ window.__ModuleLoader__.load({
 			pipProxyUrl: "",
 			cifarProxyUrl: "",
 			cifarMirror: "toronto",
-			customCifarUrl: ""
+			customCifarUrl: "",
+			parallelEval: false,
+			taskId: ""
 		};
 		const box = {
 			border: "1px solid var(--vscode-panel-border, #3c3c3c)",
@@ -159,7 +161,9 @@ window.__ModuleLoader__.load({
 				pipProxyUrl: typeof value?.pipProxyUrl === "string" ? value.pipProxyUrl : "",
 				cifarProxyUrl: typeof value?.cifarProxyUrl === "string" ? value.cifarProxyUrl : "",
 				cifarMirror: typeof value?.cifarMirror === "string" && value.cifarMirror !== "" ? value.cifarMirror : "toronto",
-				customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : ""
+				customCifarUrl: typeof value?.customCifarUrl === "string" ? value.customCifarUrl : "",
+				parallelEval: value?.parallelEval === true,
+				taskId: typeof value?.taskId === "string" ? value.taskId : ""
 			};
 		}
 		/** The settings card. */
@@ -237,8 +241,15 @@ window.__ModuleLoader__.load({
 				return () => clearInterval(timer);
 			}, []);
 			(0, react.useEffect)(() => {
-				if (state !== null && state.tasks.length > 0 && (taskId === "" || !state.tasks.some((task) => task.id === taskId))) setTaskId(state.tasks[0].id);
-			}, [state, taskId]);
+				if (state !== null && state.tasks.length > 0 && (taskId === "" || !state.tasks.some((task) => task.id === taskId))) {
+					if (draft.taskId !== "" && state.tasks.some((task) => task.id === draft.taskId)) setTaskId(draft.taskId);
+					else setTaskId(state.tasks[0].id);
+				}
+			}, [
+				state,
+				taskId,
+				draft.taskId
+			]);
 			const ready = snapshot.status === "ready" && snapshot.writable;
 			const save = async (patch) => {
 				if (!ready || snapshot.revision === void 0) return;
@@ -274,6 +285,7 @@ window.__ModuleLoader__.load({
 			};
 			const selectTask = (next) => {
 				setTaskId(next);
+				save({ taskId: next });
 				try {
 					localStorage.setItem("evalGuard.taskId", next);
 				} catch {}
@@ -332,6 +344,7 @@ window.__ModuleLoader__.load({
 			};
 			const install = async () => {
 				if (workspaceId === "" || taskId === "") return;
+				await save({ taskId });
 				setError("");
 				setNotice("");
 				setJobNotice("");
@@ -368,6 +381,7 @@ window.__ModuleLoader__.load({
 			};
 			const evaluate = async () => {
 				if (workspaceId === "" || taskId === "") return;
+				await save({ taskId });
 				setError("");
 				setNotice("");
 				setJobNotice("");
@@ -814,6 +828,23 @@ window.__ModuleLoader__.load({
 								" ",
 								t("settings.timeLimit")
 							] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+								style: { marginLeft: 16 },
+								children: [
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+										type: "checkbox",
+										checked: draft.parallelEval,
+										disabled: !ready,
+										onChange: (event) => void save({ parallelEval: event.target.checked })
+									}),
+									" ",
+									t("settings.parallelEval")
+								]
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								style: note,
+								children: t("settings.parallelEvalHint")
+							}),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
 								type: "number",
 								min: 1,
@@ -998,6 +1029,8 @@ window.__ModuleLoader__.load({
 			"settings.runningForce": "强行开启",
 			"settings.timeLimit": "开启最长时长",
 			"settings.timeLimitHint": "从每条用户消息发送时开始计时；到点只终止当前轮次，并递归清理子代理与后台任务。",
+			"settings.parallelEval": "多 agent 并行评测",
+			"settings.parallelEvalHint": "启用后，安装任务时会在提示词中提醒 agent：运行环境可能因其他 agent 的行为而波动，需要自行适应。",
 			"settings.minutes": "分钟",
 			"settings.forbidden": "额外禁止路径",
 			"settings.forbiddenHint": "每行一个绝对路径；# 开头为注释；! 开头表示在禁止范围内放开该子路径；按行顺序生效。默认空。",
@@ -1041,6 +1074,8 @@ window.__ModuleLoader__.load({
 			"settings.recent": "最近事件",
 			"settings.none": "暂无。",
 			"settings.warningTitle": "评测守护警告",
+			"settings.cifarProxy": "CIFAR 下载代理",
+			"settings.cifarMirror": "CIFAR 下载镜像",
 			"settings.close": "关闭"
 		};
 		const en = {
@@ -1053,6 +1088,8 @@ window.__ModuleLoader__.load({
 			"settings.runningForce": "Force enable",
 			"settings.timeLimit": "Enable time limit",
 			"settings.timeLimitHint": "The clock starts at each user message; at the deadline only the current turn is cancelled, and subagents/jobs are cleaned up recursively.",
+			"settings.parallelEval": "Parallel agent evaluation",
+			"settings.parallelEvalHint": "When enabled, install prompts warn the agent that the runtime may fluctuate because other agents share the machine; it must adapt.",
 			"settings.minutes": "minutes",
 			"settings.forbidden": "Extra forbidden paths",
 			"settings.forbiddenHint": "One absolute path per line; # comments; ! re-allows a subpath; later lines win. Empty by default.",