removed mooclet infrastructure, implemented native thompson-sampling …

.claude/skills/setup-perftrace/SKILL.md

@@ -387,7 +387,7 @@ file they live in. Verify against the branch rather than trusting this table if
 | `PATCH /v6/groupmembership` | `experimentUserService.updateGroupMembership` | controller |
 | `PATCH /v6/workinggroup` | `experimentUserService.updateWorkingGroup` | controller |
 | `PATCH /v6/useraliases` | `experimentUserService.setAliasesForUser(aliases=N)` | controller |
-| `POST /v6/reward` | `moocletRewardsService.sendReward` | controller |
+| `POST /v6/reward` | `thompsonSamplingRewardService.acceptReward` | controller |
 | `POST /v6/mark` | `experimentAssignmentService.markExperimentPoint` | controller |
 | " | 8 spans inside `markExperimentPoint` — `previewUserService.findOneFromCache`, `getCachedExperiments`, `checkUserOrGroupIsGloballyExcluded`, `experimentLevelExclusionInclusion`, `monitoredDecisionPointRepository.findOne`, `saveGroupExclusionDoc`, `updateEnrollmentExclusionDocumentsAndCheckEndingCriteria`, `monitoredDecisionPointRepository.saveRawJson` | `services/ExperimentAssignmentService.ts` |
 | `POST /v6/assign` | `formatAssignments` (sync) | controller |

clientlibs/js/package.json

@@ -50,7 +50,8 @@
     "docs:markdown": "typedoc --options typedoc.json",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "quicktest": "([ -d dist ] || yarn build) && ts-node quickTest.ts"
+    "quicktest": "([ -d dist ] || yarn build) && ts-node quickTest.ts",
+    "quicktest:adaptive": "([ -d dist ] || yarn build) && ts-node quickTestAdaptive.ts"
   },
   "keywords": [],
   "author": "",

clientlibs/js/quickTestAdaptive.ts

@@ -0,0 +1,218 @@
+// to run: npx ts-node clientlibs/js/quickTestAdaptive.ts
+//
+// Manual smoke test for Thompson Sampling (adaptive) experiments end-to-end:
+//   1. Creates a real experiment via the admin API (POST /experiments) and starts enrollment.
+//   2. Simulates a batch of synthetic users each calling /v6/init -> /v6/assign -> /v6/mark ->
+//      /v6/reward, the same sequence a real client would.
+//   3. Prints the reward summary (GET /experiments/rewards/:id) -- the same data the frontend's
+//      Reward Feedback card reads -- so you can watch "Pending rewards" cycle with batchSize and
+//      "Algorithm in Effect" flip from Random Assignment to Thompson Sampling as warmupThreshold
+//      is crossed, without opening a browser.
+//   4. Deletes the experiment when done (see CLEANUP_AFTER_RUN below).
+//
+// Local dev only. See ADMIN_TOKEN below for why.
+
+import axios, { AxiosError } from 'axios';
+import UpgradeClient from './dist/node';
+
+const URL = {
+  // 3030 is the standard docker-compose port (see root CLAUDE.md); a git worktree set up via
+  // /new-worktree auto-assigns its own port instead (check packages/backend/.env's APP_PORT) --
+  // update this if you're running in a worktree.
+  LOCAL: 'http://localhost:3030',
+  ECS_QA: 'https://apps.qa-cli.net/upgrade-service',
+  ECS_STAGING: 'https://apps.qa-cli.com/upgrade-service',
+};
+
+// -------------------------------------------------------------------------------------------
+// Admin auth
+// -------------------------------------------------------------------------------------------
+// authorizationChecker.ts (packages/backend/src/auth/) bypasses real Google token validation
+// for this exact string, attaching a dev admin user instead -- but only when the target
+// server's GOOGLE_AUTH_TOKEN_REQUIRED env var is false (check packages/backend/.env; this is
+// this worktree's current local setting, not a given for every environment). This will NOT
+// work against a real deployed server. Value must match FAKE_DEV_CREDENTIAL in
+// packages/types/src/User/index.ts -- hardcoded rather than imported from upgrade_types
+// because this file runs directly under ts-node (see quickTest.ts), which doesn't resolve the
+// upgrade_types path alias at runtime the way a webpack-built consumer does.
+const ADMIN_TOKEN = 'fake-dev-user-google-credential';
+
+// -------------------------------------------------------------------------------------------
+// Config -- edit these to change what gets created/simulated
+// -------------------------------------------------------------------------------------------
+const hostUrl = URL.LOCAL;
+const adminApiUrl = hostUrl + '/api';
+const context = 'upgrade-internal';
+const site = 'quicktest-adaptive-site';
+const target = 'quicktest-adaptive-target';
+
+// Adaptive algorithm parameters -- see packages/frontend .../thompson-sampling-helper.service.ts
+// and the Reward Feedback card for how these show up in the UI.
+const BATCH_SIZE = 3; // rewards buffered before posteriors update; watch "Pending rewards" cycle 0..batchSize-1
+const WARMUP_THRESHOLD = 4; // reward-count gate before real TS sampling kicks in; watch "Algorithm in Effect" flip
+const MINIMUM_DRAW_DIFFERENCE = 0;
+
+const CONDITIONS = [
+  { tempId: 'quicktest-cond-control', conditionCode: 'control', priorSuccess: 1, priorFailure: 1 },
+  { tempId: 'quicktest-cond-variant', conditionCode: 'variant', priorSuccess: 1, priorFailure: 1 },
+];
+
+const NUM_SIMULATED_USERS = 10;
+// Each simulated user's reward outcome. A fixed pattern by default so runs are reproducible --
+// swap in `Math.random() < 0.7 ? 'SUCCESS' : 'FAILURE'` if you want noisy data instead.
+function rewardForUser(index: number): 'SUCCESS' | 'FAILURE' {
+  return index % 3 === 0 ? 'FAILURE' : 'SUCCESS';
+}
+
+const CLEANUP_AFTER_RUN = false; // delete the created experiment when the script finishes
+
+// -------------------------------------------------------------------------------------------
+
+const adminClient = axios.create({
+  baseURL: adminApiUrl,
+  headers: { Authorization: `Bearer ${ADMIN_TOKEN}` },
+});
+
+quickTestAdaptive();
+
+/** main test *******************************************************************************/
+async function quickTestAdaptive() {
+  const experiment = await createAdaptiveExperiment();
+  if (!experiment) return;
+
+  console.log(`\n[Created experiment]: ${experiment.id} (${experiment.name})`);
+  console.log(
+    '[Conditions]:',
+    experiment.conditions.map((c: { conditionCode: string; id: string }) => `${c.conditionCode}=${c.id}`).join(', ')
+  );
+
+  await setExperimentState(experiment.id, 'enrolling');
+  console.log('[Experiment state]: enrolling');
+
+  for (let i = 0; i < NUM_SIMULATED_USERS; i++) {
+    await simulateUser(i, experiment.id);
+  }
+
+  // /v6/reward is fire-and-forget (POST /v6/reward acknowledges before the DB write happens --
+  // see ThompsonSamplingRewardService.acceptReward()), so give the background processing a beat
+  // to finish before reading the summary back, or the last few rewards may not show up yet.
+  await sleep(1000);
+
+  await printRewardsSummary(experiment.id);
+
+  if (CLEANUP_AFTER_RUN) {
+    await deleteExperiment(experiment.id);
+    console.log(`\n[Cleaned up]: deleted experiment ${experiment.id}`);
+  } else {
+    console.log(`\n[Left in place]: experiment ${experiment.id} -- delete manually when done.`);
+  }
+}
+
+/** admin API calls (experiment CRUD) *******************************************************/
+
+async function createAdaptiveExperiment(): Promise<{
+  id: string;
+  name: string;
+  conditions: { id: string; conditionCode: string }[];
+} | null> {
+  const payload = {
+    name: `quicktest-adaptive-${Date.now()}`,
+    description: 'Created by clientlibs/js/quickTestAdaptive.ts -- safe to delete.',
+    context: [context],
+    state: 'inactive',
+    consistencyRule: 'individual',
+    assignmentUnit: 'individual',
+    postExperimentRule: 'continue',
+    tags: ['quicktest'],
+    filterMode: 'includeAll', // excludeAll would exclude every user unless individually/group included via a segment
+    type: 'Simple',
+    assignmentAlgorithm: 'thompson_sampling',
+    // Conditions/partitions need a client-supplied id even though the server regenerates its
+    // own -- ExperimentService.create() remaps thompsonSamplingConfig.priors from these ids onto
+    // the server-generated ones automatically (see ThompsonSamplingExperimentCrudService).
+    conditions: CONDITIONS.map((c, index) => ({
+      id: c.tempId,
+      name: c.conditionCode,
+      description: '',
+      conditionCode: c.conditionCode,
+      assignmentWeight: 100 / CONDITIONS.length, // ignored for Thompson Sampling, but required by the DTO
+      order: index + 1,
+    })),
+    partitions: [{ id: 'quicktest-adaptive-dp-1', site, target, description: '', order: 1, excludeIfReached: false }],
+    thompsonSamplingConfig: {
+      warmupThreshold: WARMUP_THRESHOLD,
+      batchSize: BATCH_SIZE,
+      minimumDrawDifference: MINIMUM_DRAW_DIFFERENCE,
+      priors: Object.fromEntries(
+        CONDITIONS.map((c) => [c.tempId, { success: c.priorSuccess, failure: c.priorFailure }])
+      ),
+    },
+  };
+
+  try {
+    const response = await adminClient.post('/experiments', payload);
+    return response.data;
+  } catch (error) {
+    logAxiosError('Create experiment', error);
+    return null;
+  }
+}
+
+async function setExperimentState(experimentId: string, state: string): Promise<void> {
+  try {
+    await adminClient.post('/experiments/state', { experimentId, state });
+  } catch (error) {
+    logAxiosError('Set experiment state', error);
+  }
+}
+
+async function printRewardsSummary(experimentId: string): Promise<void> {
+  try {
+    const response = await adminClient.get(`/experiments/rewards/${experimentId}`);
+    console.log('\n[Rewards summary]:', JSON.stringify(response.data, null, 2));
+  } catch (error) {
+    logAxiosError('Rewards summary', error);
+  }
+}
+
+async function deleteExperiment(experimentId: string): Promise<void> {
+  try {
+    await adminClient.delete(`/experiments/${experimentId}`);
+  } catch (error) {
+    logAxiosError('Delete experiment', error);
+  }
+}
+
+/** simulated user flow (client SDK, same as a real client would call) **********************/
+
+async function simulateUser(index: number, experimentId: string): Promise<void> {
+  const userId = `quicktest_adaptive_user_${Date.now()}_${index}`;
+  const client = new UpgradeClient(userId, hostUrl, context);
+
+  try {
+    await client.init();
+
+    const assignment = await client.getDecisionPointAssignment(site, target);
+    const condition = assignment.getCondition();
+    await assignment.markDecisionPoint(UpgradeClient.MARKED_DECISION_POINT_STATUS.CONDITION_APPLIED);
+
+    const rewardValue = rewardForUser(index);
+    await client.sendReward({ rewardValue, experimentId });
+
+    console.log(`[User ${index}]: condition=${condition} reward=${rewardValue}`);
+  } catch (error) {
+    logAxiosError(`User ${index}`, error);
+  }
+}
+
+/** utility functions *************************************************************************/
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function logAxiosError(functionContext: string, error: unknown): void {
+  const axiosError = error as AxiosError;
+  const data = axiosError?.response?.data;
+  console.error(`\n[${functionContext} error]:`, data ?? axiosError?.message ?? error);
+}

clientlibs/js/src/UpGradeClient/UpgradeClient.ts

@@ -630,7 +630,7 @@ export default class UpgradeClient {
   }
 
   /**
-   * Sends a binary reward signal for an adaptive experiment (Mooclet).
+   * Sends a binary reward signal for an adaptive experiment.
    *
    * This method allows sending reward feedback (SUCCESS or FAILURE) for adaptive experiments.
    * The reward is used by the adaptive algorithm to update its learning model and improve future assignments.

clientlibs/js/src/types/Interfaces.ts

@@ -109,13 +109,6 @@ export namespace UpGradeClientInterfaces {
       context?: string;
       decisionPoint?: IDecisionPoint;
     };
-    reward: {
-      variable: string;
-      value: number;
-      mooclet: number;
-      version: number;
-      learner: string;
-    };
   }
 
   export interface IHttpClientWrapperRequestConfig {

clientlibs/python/BUILD_PLAN.md

@@ -103,7 +103,7 @@ class BinaryRewardValue(str, Enum):
 - `MarkDecisionPointResponse` — userId, site, target, experimentId
 - `LogEventResponse` — id, uniquifier, timeStamp, data
 - `UserAliasResponse` — userId, aliases
-- `SendRewardResponse` — message, request (rewardValue, experimentId, context, decisionPoint), reward (variable, value, mooclet, version, learner)
+- `SendRewardResponse` — message, request (rewardValue, experimentId, context, decisionPoint)
 - `ErrorResponse` — message, httpStatusCode, type
 
 ### Deliverable

clientlibs/python/src/upgrade_client_lib/client.py

@@ -330,7 +330,7 @@ async def send_reward(
         context: str | None = None,
         decision_point: dict[str, str] | None = None,
     ) -> SendRewardResponse:
-        """Send a binary reward signal for an adaptive (Mooclet) experiment."""
+        """Send a binary reward signal for an adaptive experiment."""
         return await self._api_service.send_reward(
             reward_value=reward_value,
             experiment_id=experiment_id,

clientlibs/python/src/upgrade_client_lib/types/__init__.py

@@ -33,7 +33,6 @@
     LogEventResponse,
     MarkDecisionPointResponse,
     Payload,
-    RewardDetails,
     RewardRequest,
     SendRewardResponse,
     UserAliasResponse,
@@ -71,7 +70,6 @@
     "LogEventResponse",
     "MarkDecisionPointResponse",
     "Payload",
-    "RewardDetails",
     "RewardRequest",
     "SendRewardResponse",
     "UserAliasResponse",

clientlibs/python/src/upgrade_client_lib/types/responses.py

@@ -74,18 +74,9 @@ class RewardRequest(BaseModel):
     decisionPoint: dict[str, str] | None = None
 
 
-class RewardDetails(BaseModel):
-    variable: str
-    value: float
-    mooclet: int
-    version: int
-    learner: str
-
-
 class SendRewardResponse(BaseModel):
     message: str
     request: RewardRequest
-    reward: RewardDetails
 
 
 class ErrorResponse(BaseModel):

clientlibs/python/tests/test_api_service.py

@@ -406,7 +406,6 @@ async def test_sends_aliases(self) -> None:
 REWARD_RESPONSE = {
     "message": "Reward sent",
     "request": {"rewardValue": "SUCCESS", "experimentId": "exp-1"},
-    "reward": {"variable": "score", "value": 1.0, "mooclet": 42, "version": 3, "learner": USER_ID},
 }
 
 
@@ -416,13 +415,13 @@ async def test_async_minimal(self) -> None:
         respx.post(f"{BASE}/reward").mock(return_value=Response(200, json=REWARD_RESPONSE))
         result = await make_service().send_reward(BinaryRewardValue.SUCCESS)
         assert result.message == "Reward sent"
-        assert result.reward.variable == "score"
+        assert result.request.experimentId == "exp-1"
 
     @respx.mock
     def test_sync(self) -> None:
         respx.post(f"{BASE}/reward").mock(return_value=Response(200, json=REWARD_RESPONSE))
         result = make_service().send_reward_sync(BinaryRewardValue.SUCCESS)
-        assert result.reward.mooclet == 42
+        assert result.message == "Reward sent"
 
     @respx.mock
     async def test_full_params(self) -> None:

clientlibs/python/tests/test_client.py

@@ -68,7 +68,6 @@
 REWARD_PAYLOAD = {
     "message": "ok",
     "request": {"rewardValue": "SUCCESS"},
-    "reward": {"variable": "score", "value": 1.0, "mooclet": 1, "version": 1, "learner": USER},
 }
 
 
@@ -596,7 +595,7 @@ async def test_async_success(self) -> None:
         respx.post(f"{BASE}/reward").mock(return_value=Response(200, json=REWARD_PAYLOAD))
         result = await make_client().send_reward(BinaryRewardValue.SUCCESS)
         assert result.message == "ok"
-        assert result.reward.variable == "score"
+        assert result.request.rewardValue == BinaryRewardValue.SUCCESS
 
     @respx.mock
     async def test_passes_all_params(self) -> None:
@@ -617,4 +616,4 @@ async def test_passes_all_params(self) -> None:
     def test_sync(self) -> None:
         respx.post(f"{BASE}/reward").mock(return_value=Response(200, json=REWARD_PAYLOAD))
         result = make_client().send_reward_sync(BinaryRewardValue.SUCCESS)
-        assert result.reward.mooclet == 1
+        assert result.message == "ok"

packages/backend/.env.docker.local.example

@@ -88,15 +88,6 @@ EMAIL_EXPIRE_AFTER_SECONDS=36000
 EMAIL_BUCKET="s3_bucket"
 EMAIL_TMP_WRITEABLE_FILE_PATH="src/api/assets/files/"
 
-#
-# Mooclets
-#
-
-MOOCLETS_ENABLED = false
-MOOCLETS_HOST_URL = mooclet_host_url
-MOOCLETS_API_ROUTE = /engine/api/v1
-MOOCLETS_API_TOKEN = some_token
-
 #
 # Initialization
 #

packages/backend/.env.example

@@ -90,15 +90,6 @@ EMAIL_EXPIRE_AFTER_SECONDS=36000
 EMAIL_BUCKET="s3_bucket"
 EMAIL_TMP_WRITEABLE_FILE_PATH="src/api/assets/files/"
 
-#
-# Mooclets
-#
-
-MOOCLETS_ENABLED=false
-MOOCLETS_HOST_URL=mooclet_host_url
-MOOCLETS_API_ROUTE=/engine/api/v1
-MOOCLETS_API_TOKEN=some_token
-
 #
 # Initialization
 #