`nx_write.nx` source

↩ module page · 488 lines · 22055 B
1// nx_write.nx -- W-BB-1: THE WRITE LANE'S BACKBONE. The organ that actually WRITES.
2//
3// u2605u2605u2605u2605u2605u2605THE GAP THIS CLOSES, AND IT IS EMBARRASSING IN THE RIGHT WAY. The write lane had a ruler
4// (nx_writebench, 625 permil), a panel-reliability bound, a real-person gate, a greeting-structure
5// grader, a campaign continuity checker and a per-turn dialogue meter -- and NO GENERATOR.
6// `nx_writer_run` is 9 functions that emit scaffolding and contain no inference call whatsoever: no
7// engine, no model, no HTTP. Meanwhile the local engine answers /v1/chat/completions in ~1.4s and
8// has all along; the gen lane has been using it for images and chat for weeks.
9// u21d2 WE HAD BUILT GRADERS FOR A THING THAT COULD NOT PRODUCE.
10// u2605u2605u2605u2605u2605u2605A LANE WITH RULERS AND NO PRODUCER MEASURES NOTHING -- COVERAGE ON AN EMPTY LANE IS A
11// NUMBER ABOUT THE RULER, NOT ABOUT A CAPABILITY.
12//
13// WHAT THIS IS: prompt -> real prose, on the local engine, for every mode in the registry --
14// the writing equivalent of what nx_gen is for images.
15//
16// u2605THE SEAM IS ENFORCED BY CONSTRUCTION, NOT BY POLICY TEXT. write_modes.tsv declares per mode a
17// REGISTER (sfw|mixed|explicit) and a LANE (tutor|local). An `explicit` mode may only run on the
18// `local` lane -- it never leaves this machine. That is a routing fact checked here before a single
19// byte is sent, so it cannot be forgotten by a caller or argued away by a prompt.
20//
21// u2605ENDPOINT FROM THE SWARM SSOT, never a literal: se_addr("gpu-image") -- the same single source the
22// gen daemon resolves per request, so a DHCP move heals both lanes at once (the 6-hardcoded-sites
23// outage is not repeated here).
24//
25//   nx_write <mode> <prompt...>   -- generate; prose to stdout
26//   nx_write modes                -- list the registry
27// license_tier: ORIGINAL  expect_exit: 0
28// module: nishi-core.write.backbone
29import "nx_syscalls.nx"
30import "nx_estate_path.nx"
31import "nx_connect.nx"
32import "nx_swarm_endpoint_lib.nx"
33import "nx_store_seed_lib.nx"
34import "nx_lane_conf.nx"
35const W_MAGIC_4096: i64 = 4096
36// THE MODE REGISTRY IS A SEG-STORE PLANE (info-plane doctrine 2026-08-01: registries are planes,
37// never TSVs). Seed/refresh via `nx_write migrate` (reads the tombstoned tsv one more time and
38// re-seeds); every lookup reads the plane and FAILS CLOSED if it is unseeded -- a silent tsv
39// fallback here would be a forked SSOT wearing a convenience.
40const W_PLANE: *u8 = "knowledge/store/writemode-"
41
42const W_BUF:      i64 = 1048576
43const W_REQ:      i64 = 262144
44// u26a0the three below are ABSENT-CONF FALLBACKS ONLY (rule 11): the live values are rows in
45// knowledge/write_lane.conf, hot-read via nx_lane_conf -- edit the conf, never these.
46const W_TMO_SEC:  i64 = 300
47const W_MAXTOK:   i64 = 1200
48const W_LEN_MIN:  i64 = 200
49const W_LEN_MAX:  i64 = 8000
50
51func ww(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
52func we(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(2, s, n); return 0 }
53func w_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
54func w_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; var a: i64 = o; while s[i] != (0 as u8) { d[a] = s[i]; a = a + 1; i = i + 1 } return a }
55func w_catn(d: *u8, o: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(32)
  var m: i64 = v; var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var a: i64 = o; var j: i64 = k - 1
  while j >= 0 { d[a] = t[j]; a = a + 1; j = j - 1 }
  return a
63}
64// JSON-escape into dst
65func w_jesc(d: *u8, o: i64, s: *u8) -> i64 {
  var a: i64 = o; var i: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] & 0xff
      if c == 34 { d[a] = 92 as u8; a = a + 1; d[a] = 34 as u8; a = a + 1 }
      else { if c == 92 { d[a] = 92 as u8; a = a + 1; d[a] = 92 as u8; a = a + 1 }
      else { if c == 10 { d[a] = 92 as u8; a = a + 1; d[a] = 110 as u8; a = a + 1 }
      else { if c < 32 { d[a] = 32 as u8; a = a + 1 } else { d[a] = s[i]; a = a + 1 } } } }
      i = i + 1
  }
  return a
76}
77func w_slurp(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = ep_open_rd(path)
  if fd < 0 { return 0 - 1 }
  var t: i64 = 0
  var r: i64 = 1
  while r > 0 {
      if t >= cap { r = 0 } else { r = sys_read(fd, ((buf as i64) + t) as *u8, cap - t); if r > 0 { t = t + r } }
  }
  sys_close(fd)
  return t
87}
88func w_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != (0 as u8) { return 0 }
  return 1
93}
94// copy field <idx> (tab-separated) of row [s,e) into out; returns length
95func w_field(buf: *u8, s: i64, e: i64, idx: i64, out: *u8, cap: i64) -> i64 {
  var p: i64 = s
  var f: i64 = 0
  while f < idx {
      var go: i64 = 1
      while go == 1 {
          if p >= e { go = 0 } else { if buf[p] == (9 as u8) { p = p + 1; go = 0 } else { p = p + 1 } }
      }
      f = f + 1
  }
  if p >= e { out[0] = 0 as u8; return 0 }
  var k: i64 = 0
  while p < e {
      if buf[p] == (9 as u8) { p = e } else {
          if k < cap - 1 { out[k] = buf[p]; k = k + 1 }
          p = p + 1
      }
  }
  out[k] = 0 as u8
  return k
115}
116
117// parse unsigned digits from s starting at pi[0]; advances pi past them. 0 if none.
118func w_atoi(s: *u8, pi: *i64) -> i64 {
  var i: i64 = pi[0]
  var v: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if s[i] < (48 as u8) { run = 0 } else {
          if s[i] > (57 as u8) { run = 0 } else { v = v*10 + ((s[i] as i64) - 48); i = i + 1 }
      }
  }
  pi[0] = i
  return v
129}
130
131// look up a mode row -> register/lane/structure (+ optional col5 max_tokens, col6 arc).
132// Old 5-column rows stay valid: missing fields come back empty -> caller defaults. 1 = found.
133func w_mode_lookup(mode: *u8, reg: *u8, lane: *u8, structure: *u8, mtok: *u8, arc: *u8) -> i64 {
  let buf: *u8 = sys_mmap(W_BUF)
  let n: i64 = sts_load(W_PLANE, buf, W_BUF)
  if n <= 0 { return 0 - 1 }
  let nm: *u8 = sys_mmap(128)
  var p: i64 = 0
  while p < n {
      var e: i64 = n
      var q: i64 = p
      var go: i64 = 1
      while go == 1 {
          if q >= n { e = n; go = 0 } else { if buf[q] == (10 as u8) { e = q; go = 0 } else { q = q + 1 } }
      }
      if e > p {
          if buf[p] != (35 as u8) {                    // skip comments
              w_field(buf, p, e, 0, nm, 128)
              if w_streq(nm, mode) == 1 {
                  w_field(buf, p, e, 1, reg, 64)
                  w_field(buf, p, e, 2, lane, 64)
                  w_field(buf, p, e, 3, structure, 64)
                  w_field(buf, p, e, 5, mtok, 16)
                  w_field(buf, p, e, 6, arc, 16)
                  return 1
              }
          }
      }
      p = e + 1
  }
  return 0
162}
163
164func w_list_modes() -> i64 {
  let buf: *u8 = sys_mmap(W_BUF)
  let n: i64 = sts_load(W_PLANE, buf, W_BUF)
  if n <= 0 { we("nx_write: writemode- plane unseeded -- run `nx_write migrate` once\n\x00" as *u8); return 1 }
  ww("# writemode- plane (SSOT; columns: mode register lane structure description [max_tokens] [arc])\n" as *u8)
  sys_write(1, buf, n)
  return 0
171}
172
173// one-time (re)seed: read the tombstoned tsv, keep DATA rows only, sts_seed the plane, report parity.
174func w_migrate() -> i64 {
  let raw: *u8 = sys_mmap(W_BUF)
  let n: i64 = w_slurp("knowledge/registry/write_modes.tsv" as *u8, raw, W_BUF)
  if n <= 0 { we("nx_write migrate: write_modes.tsv unreadable\n\x00" as *u8); return 1 }
  let clean: *u8 = sys_mmap(W_BUF)
  var co: i64 = 0
  var tsvrows: i64 = 0
  var p: i64 = 0
  while p < n {
      var e: i64 = p
      var go: i64 = 1
      while go == 1 {
          if e >= n { go = 0 } else { if raw[e] == (10 as u8) { go = 0 } else { e = e + 1 } }
      }
      if e > p { if raw[p] != (35 as u8) {
          var q: i64 = p
          while q < e { clean[co] = raw[q]; co = co + 1; q = q + 1 }
          clean[co] = 10 as u8; co = co + 1
          tsvrows = tsvrows + 1
      } }
      p = e + 1
  }
  let seeded: i64 = sts_seed(W_PLANE, clean, co)
  ww("WRITEMODE-MIGRATE tsv_rows=" as *u8)
  let nb: *u8 = sys_mmap(32)
  var nn: i64 = w_catn(nb, 0, tsvrows)
  sys_write(1, nb, nn)
  ww(" plane_rows=" as *u8)
  nn = w_catn(nb, 0, seeded)
  sys_write(1, nb, nn)
  if seeded == tsvrows { ww(" PARITY-OK (plane is now the SSOT; tsv is a tombstone)\n" as *u8); return 0 }
  ww(" PARITY-FAIL -- do not tombstone, investigate\n" as *u8)
  return 1
207}
208
209// system prompt per STRUCTURE -- the registry's own column drives it, so adding a mode is a row edit.
210// arc column: "complete" = carry the piece through its FULL arc (the fade-out class: a scene prompt
211// that says "end on a beat that invites what comes next" plus a token ceiling reads as coy
212// truncation -- for modes that declare complete, the ending is part of the deliverable).
213func w_system_for(structure: *u8, arc: *u8, out: *u8) -> i64 {
  var o: i64 = w_cat(out, 0, "You are a skilled prose writer. Write the piece itself with no preamble, no meta-commentary, and no headings unless the form requires them. " as *u8)
  if w_streq(structure, "scene" as *u8) == 1 {
      o = w_cat(out, o, "Write a scene: establish who is present and where, let something happen, and end on a beat that invites what comes next. Concrete sensory detail over summary." as *u8)
  } else { if w_streq(structure, "scenario" as *u8) == 1 {
      o = w_cat(out, o, "Open a scenario the reader can step into. Three beats: introduce the speaker, establish the situation already in motion, then address the reader directly and hand them the move." as *u8)
  } else { if w_streq(structure, "panel" as *u8) == 1 {
      o = w_cat(out, o, "Write a page script as numbered PANEL blocks. Each panel: one line of visual description, then any dialogue." as *u8)
  } else { if w_streq(structure, "tone" as *u8) == 1 {
      o = w_cat(out, o, "Match the requested voice closely. Keep sentence rhythm and diction consistent throughout." as *u8)
  } else { if w_streq(structure, "imrad" as *u8) == 1 {
      o = w_cat(out, o, "Use IMRaD structure: Introduction, Methods, Results, Discussion. Be precise and cite nothing you cannot support." as *u8)
  } else { if w_streq(structure, "convo" as *u8) == 1 {
      o = w_cat(out, o, "Write a natural back-and-forth conversation that keeps the topic moving." as *u8)
  } else {
      o = w_cat(out, o, "Write clearly and vividly in the form the request implies." as *u8)
  } } } } } }
  if w_streq(arc, "complete" as *u8) == 1 {
      o = w_cat(out, o, " Carry the piece through its FULL arc to an actual conclusion: the events themselves happen on the page, rendered at the same sensory depth as the rest -- never summarize past them, never fade out, never stop short. The piece ends only after its climax and a brief settling beat." as *u8)
  }
  out[o] = 0 as u8
  return o
235}
236
237// POST /v1/chat/completions to a.b.c.d:port; response into resp. returns length, -1 on failure.
238func w_engine_call(a: i64, b: i64, c: i64, d: i64, port: i64, req: *u8, reqlen: i64, resp: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_socket(2, 1, 0)
  if fd < 0 { return 0 - 1 }
  sys_set_socket_timeout(fd, W_TMO_SEC)
  let sa: *u8 = sys_mmap(16)
  sa[0] = 2 as u8; sa[1] = 0 as u8
  sa[2] = ((port >> 8) & 0xff) as u8; sa[3] = (port & 0xff) as u8
  sa[4] = a as u8; sa[5] = b as u8; sa[6] = c as u8; sa[7] = d as u8
  var z: i64 = 8
  while z < 16 { sa[z] = 0 as u8; z = z + 1 }
  if nx_connect_bounded(fd, sa, 16, NX_CONN_DEFAULT_MS) != 0 { sys_close(fd); return 0 - 1 }
  sys_write(fd, req, reqlen)
  var t: i64 = 0
  var r: i64 = 1
  while r > 0 {
      if t >= cap { r = 0 } else { r = sys_read(fd, ((resp as i64) + t) as *u8, cap - t); if r > 0 { t = t + r } }
  }
  sys_close(fd)
  return t
257}
258
259// try-connect only: 0 = reachable, nonzero = not. Bounded like every other connect here, so an
260// absent/firewalled brain costs one connect window, never a read timeout.
261func w_probe(a: i64, b: i64, c: i64, d: i64, port: i64) -> i64 {
  let fd: i64 = sys_socket(2, 1, 0)
  if fd < 0 { return 0 - 1 }
  let sa: *u8 = sys_mmap(16)
  sa[0] = 2 as u8; sa[1] = 0 as u8
  sa[2] = ((port >> 8) & 0xff) as u8; sa[3] = (port & 0xff) as u8
  sa[4] = a as u8; sa[5] = b as u8; sa[6] = c as u8; sa[7] = d as u8
  var z: i64 = 8
  while z < 16 { sa[z] = 0 as u8; z = z + 1 }
  let rc: i64 = nx_connect_bounded(fd, sa, 16, NX_CONN_DEFAULT_MS)
  sys_close(fd)
  if rc != 0 { return 0 - 1 }
  return 0
274}
275
276// pull the assistant text out of {"choices":[{"message":{"content":"..."}}]} and unescape it.
277func w_extract(resp: *u8, n: i64) -> i64 {
  let key: *u8 = "\"content\":\"" as *u8
  let kl: i64 = w_len(key)
  var i: i64 = 0
  var s: i64 = 0 - 1
  while i + kl <= n {
      var j: i64 = 0
      var same: i64 = 1
      while j < kl { if resp[i + j] != key[j] { same = 0; j = kl } else { j = j + 1 } }
      if same == 1 { s = i + kl; i = n } else { i = i + 1 }
  }
  if s < 0 { return 0 - 1 }
  let out: *u8 = sys_mmap(W_BUF)
  var o: i64 = 0
  var p: i64 = s
  var go: i64 = 1
  while go == 1 {
      if p >= n { go = 0 } else {
          let ch: i64 = resp[p] & 0xff
          if ch == 34 { go = 0 }
          else {
              if ch == 92 {
                  let nx: i64 = resp[p + 1] & 0xff
                  if nx == 110 { out[o] = 10 as u8; o = o + 1; p = p + 2 }
                  else { if nx == 116 { out[o] = 9 as u8; o = o + 1; p = p + 2 }
                  else { out[o] = resp[p + 1]; o = o + 1; p = p + 2 } }
              } else { out[o] = resp[p]; o = o + 1; p = p + 1 }
          }
      }
  }
  sys_write(1, out, o)
  ww("\n\x00" as *u8)
  return o
310}
311
312// parse "a.b.c.d:port" into w[0..4]; 1 = ok
313func w_parse_addr(s: *u8, w: *i64) -> i64 {
  var i: i64 = 0
  var f: i64 = 0
  while f < 5 {
      var v: i64 = 0
      var dig: i64 = 0
      var scan: i64 = 1
      while scan == 1 {
          let c: i64 = s[i] as i64
          if c < 48 { scan = 0 } else { if c > 57 { scan = 0 } else { v = v * 10 + (c - 48); dig = dig + 1; i = i + 1 } }
      }
      if dig == 0 { return 0 }
      w[f] = v
      f = f + 1
      if f < 5 { i = i + 1 }    // skip the '.' or ':'
  }
  return 1
330}
331
332func main(argc: i64, argv: *i64) -> i64 {
  ep_anchor()
  if argc < 2 {
      ww("usage: nx_write <mode> <prompt...>   |   nx_write modes\n\x00" as *u8)
      return 1
  }
  let mode: *u8 = argv[1] as *u8
  if w_streq(mode, "modes" as *u8) == 1 { return w_list_modes() }
  if w_streq(mode, "migrate" as *u8) == 1 { return w_migrate() }
  if argc < 3 { we("nx_write: needs a prompt\n\x00" as *u8); return 2 }
342
  let reg: *u8 = sys_mmap(64)
  let lane: *u8 = sys_mmap(64)
  let structure: *u8 = sys_mmap(64)
  let mtok: *u8 = sys_mmap(16)
  let arc: *u8 = sys_mmap(16)
  let found: i64 = w_mode_lookup(mode, reg, lane, structure, mtok, arc)
  if found < 0 { we("nx_write: writemode- plane unseeded/unreadable (the plane is the SSOT; nothing is guessed) -- run `nx_write migrate`\n\x00" as *u8); return 3 }
  if found == 0 {
      we("nx_write: unknown mode -- run `nx_write modes` for the registry\n\x00" as *u8)
      return 4
  }
354
  // u2605THE SEAM, CHECKED BEFORE A BYTE IS SENT: an explicit register may only run on the local lane.
  if w_streq(reg, "explicit" as *u8) == 1 {
      if w_streq(lane, "local" as *u8) == 0 {
          we("nx_write REFUSED: mode is register=explicit but lane=\x00" as *u8); we(lane)
          we(" -- an explicit register may only run on the local lane. Fix the registry row, not this call.\n\x00" as *u8)
          return 5
      }
  }
363
  // SPOKE-YIELD ADMISSION (operator 2026-08-05): if the spoke's sentinel reports an interactive
  // GPU tenant (a game), the swarm YIELDS -- interactive sessions outrank batch generation. The
  // hub is not brought down and nothing is lost: the writer's async lane keeps the request as a
  // durable .req and the sweeper runs it when the GPU frees. Conf-driven (gpu_yield_to_games).
  if lc_write_lane("gpu_yield_to_games" as *u8, 1) == 1 {
      let gb: *u8 = sys_mmap(256)
      let gn: i64 = w_slurp("knowledge/status/gpu_avail.conf" as *u8, gb, 250)
      if gn > 0 {
          let gp: *i64 = sys_mmap(16) as *i64
          gp[0] = 0
          let gep: i64 = w_atoi(gb, gp)
          let nowt: *i64 = sys_mmap(16) as *i64
          nowt[0] = 0
          sys_clock_gettime_real(nowt)
          if nowt[0] - gep < lc_write_lane("gpu_avail_max_age_sec" as *u8, 180) {
              var gi: i64 = 0
              var isgame: i64 = 0
              while gi + 5 < gn {
                  if gb[gi]==(103 as u8) { if gb[gi+1]==(97 as u8) { if gb[gi+2]==(109 as u8) { if gb[gi+3]==(101 as u8) { if gb[gi+4]==(61 as u8) {
                      if gb[gi+5]==(110 as u8) { if gb[gi+6]==(111 as u8) { if gb[gi+7]==(110 as u8) { if gb[gi+8]==(101 as u8) { isgame = 0-1 } } } }
                      if isgame == 0 { isgame = 1 }
                      gi = gn
                  } } } } }
                  gi = gi + 1
              }
              if isgame == 1 {
                  ww("NX-WRITE-DEFERRED gpu yielded to interactive session (sentinel: game present); queued jobs run when the gpu frees\n" as *u8)
                  return 0
              }
          }
      }
  }
396
  // endpoint from the swarm SSOT -- prefer the dedicated write brain (gpu-write, llama-server),
  // fall back to the image engine's chat lane (gpu-image). Both rows live in knowledge/swarm_nodes.conf;
  // adding/moving a brain is a ROW EDIT, never a code edit. u2605RESOLVE IS NOT REACHABLE (the swarm
  // co_usable lesson): the preferred role must also PROBE-CONNECT, else a firewalled brain wedges
  // the lane that a healthy fallback could serve.
  var addr: *u8 = se_addr("gpu-write" as *u8)
  if (addr as i64) != 0 {
      let wp: *i64 = sys_mmap(64) as *i64
      if w_parse_addr(addr, wp) == 1 {
          if w_probe(wp[0], wp[1], wp[2], wp[3], wp[4]) != 0 { addr = 0 as *u8 }
      } else { addr = 0 as *u8 }
  }
  if (addr as i64) == 0 { addr = se_addr("gpu-image" as *u8) }
  if (addr as i64) == 0 {
      we("nx_write: neither gpu-write nor gpu-image resolvable in knowledge/swarm_nodes.conf (fail-closed; no fabricated endpoint)\n\x00" as *u8)
      return 6
  }
  let w4: *i64 = sys_mmap(64) as *i64
  if w_parse_addr(addr, w4) == 0 { we("nx_write: malformed endpoint row\n\x00" as *u8); return 6 }
416
  // length: registry col5 (per mode) -> conf default; a leading len=<N> prompt token
  // overrides per call, clamped to the conf min/max.
  var toks: i64 = lc_write_lane("write_default_max_tokens" as *u8, W_MAXTOK)
  let lmin: i64 = lc_write_lane("write_len_min" as *u8, W_LEN_MIN)
  let lmax: i64 = lc_write_lane("write_len_max" as *u8, W_LEN_MAX)
  if mtok[0] != (0 as u8) {
      let mp: *i64 = sys_mmap(16) as *i64
      mp[0] = 0
      let mv: i64 = w_atoi(mtok, mp)
      if mv > 0 { toks = mv }
  }
  // len=<N> may arrive as its OWN argv token (CLI) or as the PREFIX of a single prompt string
  // (the /write daemon passes the whole body as one arg) -- handle both.
  var ai: i64 = 2
  var a2off: i64 = 0
  let a2: *u8 = argv[2] as *u8
  if a2[0] == (108 as u8) { if a2[1] == (101 as u8) { if a2[2] == (110 as u8) { if a2[3] == (61 as u8) {
      let lp: *i64 = sys_mmap(16) as *i64
      lp[0] = 4
      let lv: i64 = w_atoi(a2, lp)
      if lv >= lmin { if lv <= lmax {
          toks = lv
          if a2[lp[0]] == (0 as u8) { ai = 3 } else {
              if a2[lp[0]] == (32 as u8) { a2off = lp[0] + 1 }
          }
      } }
  } } } }
  if ai >= argc { if a2off == 0 { we("nx_write: needs a prompt after len=\n\x00" as *u8); return 2 } }
445
  // assemble the prompt from argv[ai..] (a2off skips a consumed len= prefix inside argv[2])
  let user: *u8 = sys_mmap(W_REQ)
  var uo: i64 = 0
  while ai < argc {
      if uo > 0 { user[uo] = 32 as u8; uo = uo + 1 }
      if ai == 2 { uo = w_cat(user, uo, ((a2 as i64) + a2off) as *u8) } else { uo = w_cat(user, uo, argv[ai] as *u8) }
      ai = ai + 1
  }
  user[uo] = 0 as u8
455
  let sysp: *u8 = sys_mmap(W_MAGIC_4096)
  w_system_for(structure, arc, sysp)
458
  let body: *u8 = sys_mmap(W_REQ)
  var bo: i64 = w_cat(body, 0, "{\"model\":\"local\",\"max_tokens\":" as *u8)
  bo = w_catn(body, bo, toks)
  bo = w_cat(body, bo, ",\"messages\":[{\"role\":\"system\",\"content\":\"" as *u8)
  bo = w_jesc(body, bo, sysp)
  bo = w_cat(body, bo, "\"},{\"role\":\"user\",\"content\":\"" as *u8)
  bo = w_jesc(body, bo, user)
  bo = w_cat(body, bo, "\"}]}" as *u8)
467
  let req: *u8 = sys_mmap(W_REQ)
  var ro: i64 = w_cat(req, 0, "POST /v1/chat/completions HTTP/1.1\r\nHost: engine\r\nConnection: close\r\nContent-Type: application/json\r\nContent-Length: " as *u8)
  ro = w_catn(req, ro, bo)
  ro = w_cat(req, ro, "\r\n\r\n" as *u8)
  var bi: i64 = 0
  while bi < bo { req[ro] = body[bi]; ro = ro + 1; bi = bi + 1 }
474
  let resp: *u8 = sys_mmap(W_BUF)
  let rn: i64 = w_engine_call(w4[0], w4[1], w4[2], w4[3], w4[4], req, ro, resp, W_BUF)
  if rn <= 0 {
      we("nx_write: engine unreachable at \x00" as *u8); we(addr)
      we(" -- is the local engine up? (nishi_elara_engine_keeper.ps1)\n\x00" as *u8)
      return 7
  }
  if w_extract(resp, rn) < 0 {
      we("nx_write: engine replied but no content field -- raw response follows on stderr\n\x00" as *u8)
      sys_write(2, resp, rn)
      return 8
  }
  return 0
488}
nx_write.nx source

`nx_write.nx` source
