Update app.js

app.js

@@ -15,6 +15,7 @@
  *   4. FOCUS TRACKER: guides AI generation away from overrepresented domains.
  *   5. DOWNLOAD endpoint returns dated filename.
  *   6. RPS throttle on AI calls, SAMPLES_PER_CALL configurable.
+ *   7. AWS BEDROCK updated to ConverseCommand with NodeHttpHandler.
  *
  * Endpoints:
  *   GET  /status
@@ -37,12 +38,10 @@ import fs           from "fs";
 import path         from "path";
 import {
     BedrockRuntimeClient,
-    InvokeModelCommand,
-  ConverseCommand
+    ConverseCommand
 } from "@aws-sdk/client-bedrock-runtime";
 import { NodeHttpHandler } from "@smithy/node-http-handler";
 
-
 // ── CONFIG ────────────────────────────────────────────────────────────────────
 const PORT             = parseInt(process.env.PORT          || "7860");
 const AWS_REGION       = process.env.AWS_REGION             || "us-east-1";
@@ -53,7 +52,7 @@ const DEFAULT_RPS      = parseFloat(process.env.DEFAULT_RPS || "3");
 const MAX_RPS          = parseFloat(process.env.MAX_RPS     || "8");
 const SAMPLES_PER_CALL = parseInt(process.env.SAMPLES_PER_CALL || "20");
 const SCALE_K          = 30.0;
-const LATENT_D_MAX     = 8; // Added for correct mask padding
+const LATENT_D_MAX     = 8; 
 
 // ── LOGGING ───────────────────────────────────────────────────────────────────
 const ts  = () => new Date().toISOString().slice(11, 23);
@@ -73,17 +72,11 @@ const safeNorm = (b) => {
 const randchoice = (arr) => arr[Math.floor(Math.random() * arr.length)];
 
 // ── NORMALIZER ────────────────────────────────────────────────────────────────
-/**
- * Core pipeline fix: map raw c_values to [0,1] using declared bounds.
- * Parses vars_text like "VARS c0 IN [lo hi] c1 IN [lo hi] ..."
- * If bounds can't be parsed, clamps raw values to [0,1].
- */
 function normalizeSample(s) {
     const parsed = parseVarsBounds(s.vars_text, s.n_vars);
     
     if (!Array.isArray(s.c_values) || s.c_values.length < s.n_vars) return null;
     
-    // Tolerate if AI appended extra zeros by slicing to exact n_vars
     const raw = s.c_values.slice(0, s.n_vars);
 
     const normalized = raw.map((v, i) => {
@@ -95,7 +88,6 @@ function normalizeSample(s) {
 
     if (normalized.includes(null)) return null;
 
-    // Pad mask to the global LATENT_D_MAX requirement
     const mask =[...Array(s.n_vars).fill(1), ...Array(Math.max(0, LATENT_D_MAX - s.n_vars)).fill(0)];
 
     return {
@@ -108,14 +100,12 @@ function normalizeSample(s) {
 }
 
 function parseVarsBounds(varsText, nVars) {
-    // Returns [[lo,hi], ...] for each variable. [FIX]: Now tolerates commas
     const bounds = [];
     const re = /IN\s*[\[({]?\s*(-?[\d.e+\-]+)[\s,]+(-?[\d.e+\-]+)\s*[\])}]?/gi;
     let m;
     while ((m = re.exec(varsText)) !== null) {
         bounds.push([parseFloat(m[1]), parseFloat(m[2])]);
     }
-    // Pad with[0,1] if fewer bounds than vars
     while (bounds.length < nVars) bounds.push([0, 1]);
     return bounds;
 }
@@ -151,8 +141,6 @@ function validateSample(s) {
 
 // ═════════════════════════════════════════════════════════════════════════════
 // DEEP SYNTHETIC GENERATORS
-// Each generator builds a 2-3 scope AXL program, not just a label.
-// c_values are in raw domain units — normalizeSample() handles [0,1] mapping.
 // ═════════════════════════════════════════════════════════════════════════════
 
 // ── PHYSICS ───────────────────────────────────────────────────────────────────
@@ -242,7 +230,7 @@ function synthPhysicsSamples(n) {
                 `  END TRANSFORM`,
                 ``,
                 `  OBSERVE result EQUALS ${bRaw.toFixed(6)}`,
-                `  UNKNOWN ${cRaw.map((_,j)=>`c${j}: REAL BOUND [${t.bounds[j][0]}, ${t.bounds[j][1]}]`).join("\n  UNKNOWN ")}`,
+                `  UNKNOWN ${cRaw.map((_,j)=>`c${j}: REAL BOUND[${t.bounds[j][0]}, ${t.bounds[j][1]}]`).join("\n  UNKNOWN ")}`,
                 ``,
                 `  COLLAPSE ${t.name.toLowerCase().replace(/ /g,"_")}`,
                 `    GIVEN {result EQUALS ${bRaw.toFixed(4)}}`,
@@ -292,7 +280,7 @@ function synthFinanceSamples(n) {
             } else if (kind === "loan") {
                 const P = rnd(50000,500000), r = rnd(0.002,0.02), np = randint(60,360);
                 bRaw = P*r*(1+r)**np / ((1+r)**np - 1 + 1e-9);
-                cRaw = [P, r, np];
+                cRaw =[P, r, np];
                 bounds = [[50000,500000],[0.002,0.02],[60,360]];
                 formula = "P*r*(1+r)^n / ((1+r)^n - 1)";
                 subdomain = "loan_payment";
@@ -331,7 +319,7 @@ function synthFinanceSamples(n) {
             const varsBounds = bounds.map(([lo,hi],j)=>`c${j} IN [${lo} ${hi}]`).join(" ");
 
             const axl = [
-                `SCOPE financial_primitives [level: 0]`,
+                `SCOPE financial_primitives[level: 0]`,
                 `  ASSUME capital EXISTS`,
                 `  ASSUME time EXISTS`,
                 `  CONSERVES total_capital APPROXIMATELY ACROSS ${subdomain}`,
@@ -341,14 +329,14 @@ function synthFinanceSamples(n) {
                 `  ASSUME financial_primitives SCOPE HOLDS`,
                 ``,
                 `  ENTITY financial_system`,
-                ...bounds.map(([lo,hi],j) => `    FIELD c${j}: REAL BOUND [${lo}, ${hi}]`),
+                ...bounds.map(([lo,hi],j) => `    FIELD c${j}: REAL BOUND[${lo}, ${hi}]`),
                 `    FIELD output: REAL`,
                 `    DERIVES output FROM {${cRaw.map((_,j)=>`c${j}`).join(", ")}} BY ${subdomain}_formula`,
                 `    TENDS output ${ kind==="portfolio_variance"?"MIN":"MAX" }`,
                 `  END ENTITY`,
                 ``,
                 `  TRANSFORM ${subdomain}_formula`,
-                `    INPUT  {${bounds.map(([lo,hi],j)=>`c${j}: REAL BOUND [${lo},${hi}]`).join(", ")}}`,
+                `    INPUT  {${bounds.map(([lo,hi],j)=>`c${j}: REAL BOUND[${lo},${hi}]`).join(", ")}}`,
                 `    OUTPUT {result: REAL}`,
                 `    PRODUCES result EQUALS ${formula}`,
                 `  END TRANSFORM`,
@@ -386,7 +374,7 @@ function synthFinanceSamples(n) {
     return samples;
 }
 
-// ── CRYPTOGRAPHY (full depth — from synthCryptoSamples.js) ───────────────────
+// ── CRYPTOGRAPHY ─────────────────────────────────────────────────────────────
 function synthXorSamples(n) {
     const samples =[];
     for (let i = 0; i < n; i++) {
@@ -433,11 +421,11 @@ function synthXorSamples(n) {
             `    FIELD raw: INTEGER BOUND [0, 255] EQUALS ${plain}`,
             `  END ENTITY`,
             `  ENTITY cipher_byte`,
-            `    FIELD raw: INTEGER BOUND [0, 255]`,
+            `    FIELD raw: INTEGER BOUND[0, 255]`,
             `    DERIVES raw FROM {key_byte.raw, plain_byte.raw} BY xor_byte_transform`,
             `  END ENTITY`,
             `  TRANSFORM xor_byte_transform`,
-            `    INPUT  {key: INTEGER BOUND[0,255], plain: INTEGER BOUND [0,255]}`,
+            `    INPUT  {key: INTEGER BOUND [0,255], plain: INTEGER BOUND[0,255]}`,
             `    OUTPUT {cipher: INTEGER BOUND [0,255]}`,
             `    CONSERVES nothing`,
             `    CHANGES cipher`,
@@ -497,7 +485,7 @@ function synthCaesarSamples(n) {
             `  ASSUME modular_arithmetic HOLDS`,
             `  ENTITY alphabet`,
             `    FIELD size: INTEGER EQUALS 26`,
-            `    BOUND any_char WITHIN[0, 25]`,
+            `    BOUND any_char WITHIN [0, 25]`,
             `  END ENTITY`,
             `  TRANSFORM modular_add`,
             `    INPUT  {a: INTEGER, b: INTEGER, mod: INTEGER}`,
@@ -527,12 +515,12 @@ function synthCaesarSamples(n) {
             `SCOPE caesar_message [level: 2]`,
             `  ASSUME caesar_char SCOPE HOLDS`,
             `  ENTITY message`,
-            `    FIELD plaintext:  VECTOR OF INTEGER EQUALS[${plains.join(", ")}]`,
+            `    FIELD plaintext:  VECTOR OF INTEGER EQUALS [${plains.join(", ")}]`,
             `    FIELD ciphertext: VECTOR OF INTEGER`,
             `    FIELD length:     INTEGER EQUALS ${msgLen}`,
             `    DERIVES ciphertext FROM {plaintext, shift_key.raw} BY caesar_transform APPLIED_TO_EACH`,
             `  END ENTITY`,
-            `  OBSERVE message.ciphertext EQUALS [${ciphers.join(", ")}]`,
+            `  OBSERVE message.ciphertext EQUALS[${ciphers.join(", ")}]`,
             `  OBSERVE SUM(message.ciphertext) EQUALS ${bRaw}`,
             `  UNKNOWN shift_key.normalised: REAL BOUND [0, 1]`,
             `  COLLAPSE caesar_message`,
@@ -546,7 +534,7 @@ function synthCaesarSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "caesar",
             sense: "EQUAL", n_vars: 1,
-            vars_text: "VARS c0 IN[0 25]",
+            vars_text: "VARS c0 IN [0 25]",
             expr_text: `EXPR CAESAR plains=[${plains}] ciphers=[${ciphers}] shift=UNKNOWN`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(bRaw), b_norm: fmt(safeNorm(bRaw), 8),
@@ -663,7 +651,7 @@ function synthAffineSamples(n) {
         const verify = ((aInv*(cipher-b))%26+26)%26;
         if (verify !== p) continue;
 
-        const axl =[
+        const axl = [
             `SCOPE modular_arithmetic [level: 0]`,
             `  ASSUME integer EXISTS`,
             `  TRANSFORM modular_multiply_add`,
@@ -694,20 +682,22 @@ function synthAffineSamples(n) {
             `  END ENTITY`,
             `  ENTITY affine_transform_result`,
             `    FIELD plaintext:  INTEGER BOUND[0, 25] EQUALS ${p}`,
-            `    FIELD ciphertext: INTEGER BOUND [0, 25]`,
+            `    FIELD ciphertext: INTEGER BOUND[0, 25]`,
             `    DERIVES ciphertext FROM {affine_key.a, plaintext, affine_key.b} BY modular_multiply_add`,
+            `    # f(${p}) = (${a} * ${p} + ${b}) mod 26 = ${cipher}`,
             `  END ENTITY`,
             `  ENTITY affine_inverse`,
             `    FIELD a_inv: INTEGER EQUALS ${aInv}`,
             `    FIELD recovery: INTEGER`,
             `    DERIVES recovery FROM {a_inv, ciphertext, b} BY modular_multiply_add`,
+            `    # a_inv*(cipher-b) mod 26 = ${p} ✓`,
             `  END ENTITY`,
             `  CONTRADICT invertible WITH non_coprime_a`,
             `    AT SCOPE affine_cipher`,
             `    BOUNDARY_TYPE INFORMATION`,
             `  END CONTRADICT`,
             `  OBSERVE affine_transform_result.ciphertext EQUALS ${cipher}`,
-            `  UNKNOWN affine_key.a_norm: REAL BOUND [0, 1]`,
+            `  UNKNOWN affine_key.a_norm: REAL BOUND[0, 1]`,
             `  UNKNOWN affine_key.b_norm: REAL BOUND [0, 1]`,
             `  COLLAPSE affine_cipher`,
             `    GIVEN {affine_transform_result.plaintext, affine_transform_result.ciphertext}`,
@@ -720,7 +710,7 @@ function synthAffineSamples(n) {
         samples.push({
             id: randomUUID(), domain: "cryptography", subdomain: "affine",
             sense: "EQUAL", n_vars: 2,
-            vars_text: "VARS c0 IN [0 11] c1 IN[0 25]",
+            vars_text: "VARS c0 IN[0 11] c1 IN [0 25]",
             expr_text: `EXPR AFFINE a=${a}(idx=${aIdx}) b=${b} plain=${p} cipher=${cipher}`,
             sense_text: "SENSE EQUAL",
             b_raw: fmt(cipher), b_norm: fmt(safeNorm(cipher), 8),
@@ -737,7 +727,7 @@ function synthAffineSamples(n) {
     return samples;
 }
 
-// ── OPTIMIZATION (deep AXL, not just a label) ─────────────────────────────────
+// ── OPTIMIZATION (deep AXL) ───────────────────────────────────────────────────
 function synthOptimizationSamples(n) {
     const samples =[];
     for (let i = 0; i < n; i++) {
@@ -817,13 +807,13 @@ function synthOptimizationSamples(n) {
 
 // ── SYNTHETIC GENERATOR MAP ───────────────────────────────────────────────────
 const SYNTHETIC_GENERATORS = {
-    physics:      synthPhysicsSamples,
-    finance:      synthFinanceSamples,
+    physics:              synthPhysicsSamples,
+    finance:              synthFinanceSamples,
     cryptography_xor:     synthXorSamples,
     cryptography_caesar:  synthCaesarSamples,
     cryptography_vigenere:synthVigenereSamples,
     cryptography_affine:  synthAffineSamples,
-    optimization: synthOptimizationSamples,
+    optimization:         synthOptimizationSamples,
 };
 
 // ── FOCUS TRACKER ─────────────────────────────────────────────────────────────
@@ -854,7 +844,14 @@ function saveDataset() {
 }
 
 // ── BEDROCK CLIENT ────────────────────────────────────────────────────────────
-const bedrock = new BedrockRuntimeClient({ region: AWS_REGION });
+
+// Initialize Bedrock Client with NodeHttpHandler explicitly
+const bedrockClient = new BedrockRuntimeClient({
+    region: AWS_REGION,
+    requestHandler: new NodeHttpHandler({
+        http2Handler: undefined, 
+    }) 
+});
 
 const AXL_SPEC = `
 # AXL — Abstraction Exchange Language
@@ -998,7 +995,7 @@ The system will work backwards from this to find what
 configuration of unknowns is consistent with it.
 
 OBSERVE <field | entity | state> EQUALS <value>
-OBSERVE <field> WITHIN[<min>, <max>]
+OBSERVE <field> WITHIN [<min>, <max>]
 OBSERVE <pattern> IN <output>
 
 ---
@@ -1009,7 +1006,7 @@ The system navigates the abstraction domain to find
 values of UNKNOWNs that satisfy all constraints
 given the OBSERVATIONs.
 
-UNKNOWN <name>: <type> BOUND [<min>, <max>]
+UNKNOWN <name>: <type> BOUND[<min>, <max>]
 UNKNOWN <name>: DISCRETE WITHIN <set>
 
 ---
@@ -1260,7 +1257,7 @@ SCOPE nucleus[level: 2]
 END SCOPE
 
 
-SCOPE atom [level: 3]
+SCOPE atom[level: 3]
 
   ASSUME nucleus SCOPE HOLDS
 
@@ -1298,7 +1295,7 @@ END SCOPE
 OBSERVE spectral_emission EQUALS {656nm, 486nm, 434nm, 410nm}
 
 UNKNOWN element: SYMBOLIC WITHIN periodic_table
-UNKNOWN atomic_number: INTEGER BOUND [1, 118]
+UNKNOWN atomic_number: INTEGER BOUND[1, 118]
 UNKNOWN electron_configuration: VECTOR
 
 COLLAPSE atom
@@ -1384,7 +1381,7 @@ SCOPE block_header[level: 2]
   ASSUME sha256_internals SCOPE HOLDS
 
   ENTITY block_header
-    FIELD version: INTEGER BOUND [1, 4]
+    FIELD version: INTEGER BOUND[1, 4]
     FIELD prev_hash: bit_array BOUND length EQUALS 256   # GIVEN, fixed
     FIELD merkle_root: bit_array BOUND length EQUALS 256 # GIVEN, fixed
     FIELD timestamp: INTEGER                              # GIVEN, approximately fixed
@@ -1414,7 +1411,7 @@ SCOPE mining [level: 3]
   OBJECTIVE valid_block
     OPTIMIZE hash MIN                        # minimize hash value numerically
     SUBJECT TO hash BELOW target             # hard bound — must be satisfied
-    SUBJECT TO nonce WITHIN [0, 4294967295]
+    SUBJECT TO nonce WITHIN[0, 4294967295]
   END OBJECTIVE
 
   # ══ HERE IS THE INTELLIGENCE LAYER ══
@@ -1488,7 +1485,7 @@ axl:
 # with error correction and state machines
 # ════════════════════════════════════════════════════
 
-SCOPE molecular [level: 0]
+SCOPE molecular[level: 0]
 
   ASSUME molecule EXISTS
   ASSUME information CAN BE ENCODED IN molecule
@@ -1523,7 +1520,7 @@ SCOPE molecular [level: 0]
 END SCOPE
 
 
-SCOPE genome [level: 1]
+SCOPE genome[level: 1]
 
   ASSUME molecular SCOPE HOLDS
 
@@ -1772,7 +1769,7 @@ JSON SCHEMA (output array of these):
   "subdomain": "<specific topic>",
   "sense": "<EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
   "n_vars": <integer>,
-  "vars_text": "VARS c0 IN[lo hi] c1 IN [lo hi] ...",
+  "vars_text": "VARS c0 IN [lo hi] c1 IN[lo hi] ...",
   "expr_text": "EXPR <description>",
   "sense_text": "SENSE <EQUAL|MINIMIZE|MAXIMIZE|SELECT|TEND>",
   "b_raw": <float>,
@@ -1796,54 +1793,24 @@ OUTPUT THE JSON ARRAY NOW:`;
 }
 
 async function callBedrock(prompt) {
-  const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1",
-    requestHandler: new NodeHttpHandler({
-        http2Handler: undefined, 
-    }) 
-});
-
-  const command = new ConverseCommand({
-                modelId: BEDROCK_MODEL,
-                system:[{ text: prompt }],
-                messages: [{ role: "user", content: {text: "OUTPUT THE JSON ARRAY NOW"} }],
-                
-                // Ensure maxTokens is large enough for reasoning + response
-                inferenceConfig: { 
-                    maxTokens: 4000, 
-                    temperature: 1 
-                },
-
-                additionalModelRequestFields: (
-                   /* if (model.includes("haiku")) {
-                        return {
-                            reasoning_config: {
-                                type: "enabled",
-                                budget_tokens: 2048 
-                            } 
-                        };
-                    } */
-                      
-                            // thinking: { type: "adaptive" },
-                  {output_config: { effort: "high" }}
-                        )
-                    
-                    
-                
-            });
-          
-            const response = await bedrockClient.send(command);
+    const command = new ConverseCommand({
+        modelId: BEDROCK_MODEL_ID,
+        messages: [{ role: "user", content:[{ text: prompt }] }],
+        inferenceConfig: { 
+            maxTokens: 10000, 
+            temperature: 0.9
+        }
+    });
 
-  
-    
-    const t0  = Date.now();
-    const res  = response;
-    const raw  = JSON.parse(Buffer.from(res.body).toString("utf8"));
-    const text = raw.content[0].text;
+    const t0 = Date.now();
+    const res = await bedrockClient.send(command);
+    const text = res.output.message.content.find(b => b.text)?.text || "";
     log(`Bedrock call ${((Date.now()-t0)/1000).toFixed(1)}s — ${text.length} chars`);
-   const tokenUsage = raw.usage ? (raw.usage.input_tokens + raw.usage.output_tokens) : 0;
-  console.log(tokenUsage)
-  return text;
+    
+    const tokenUsage = res.usage ? (res.usage.inputTokens + res.usage.outputTokens) : 0;
+    console.log("Token Usage: " + tokenUsage);
+    
+    return text;
 }
 
 function parseAIResponse(text) {
@@ -1885,7 +1852,7 @@ app.use(express.json());
 app.get("/status", (_, res) => res.json({
     dataset_size: dataset.length,
     dataset_path: DATASET_PATH,
-    bedrock_model: BEDROCK_MODEL,
+    bedrock_model: BEDROCK_MODEL_ID,
     focus_tracker: tracker.stats(),
     server_time: new Date().toISOString(),
 }));
@@ -1995,7 +1962,7 @@ app.get("/dataset/sample", (req, res) => {
 loadDataset();
 app.listen(PORT, '0.0.0.0', () => {
     log(`AXL Dataset Server listening on :${PORT}`, "OK");
-    log(`Model:   ${BEDROCK_MODEL}`);
+    log(`Model:   ${BEDROCK_MODEL_ID}`);
     log(`Dataset: ${DATASET_PATH}`);
     log(`RPS:     ${DEFAULT_RPS} default / ${MAX_RPS} max`);
 });