onbuzz 6.3.0 → 6.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "6.3.0",
+  "version": "6.3.1",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/interfaces/webServer.js

@@ -441,6 +441,11 @@ class WebServer {
       }
     }
 
+    // Per-process identity, echoed by /api/health so a caller (the Electron
+    // shell above all) can tell OUR server from another program that happens
+    // to answer on the same port. See startServer() → _verifyOwnPort().
+    this.instanceId = crypto.randomUUID();
+
     // Express app
     this.app = express();
     this.server = createServer(this.app);
@@ -1066,12 +1071,14 @@ class WebServer {
         res.json({
           status: 'healthy',
           version: packageJson.version || '1.0.0',
+          instance: this.instanceId,
           timestamp: new Date().toISOString()
         });
       } catch {
         res.json({
           status: 'healthy',
           version: '1.0.0',
+          instance: this.instanceId,
           timestamp: new Date().toISOString()
         });
       }
@@ -7834,6 +7841,47 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     }
 
+    // A successful bind is not proof we OWN the port: on Windows a 0.0.0.0
+    // bind succeeds while another program holds 127.0.0.1 on the same port,
+    // and loopback traffic goes to that program. Listen, then ask
+    // 127.0.0.1:port/api/health for our own instance id; a foreign answer
+    // means close and move on (dynamic port) or fail loudly (forced port).
+    const forced = !!(envPort && !isNaN(envPort));
+    const MAX_PORT_HOPS = 20;
+    for (let hop = 0; hop < MAX_PORT_HOPS; hop++) {
+      const owned = await this._listenAndVerify();
+      if (owned) return;
+      const foreign = this.port;
+      if (forced) {
+        throw new Error(`Port ${foreign} is answered by another program (it is in use on 127.0.0.1). Stop that program or start with a different LOXIA_PORT.`);
+      }
+      this.logger.warn('Port is answered by another program — moving to the next free port', { port: foreign, host: this.host });
+      this.port = await findFreePort(foreign + 1, 100, this.host);
+    }
+    throw new Error(`Could not find a port that is not answered by another program (tried ${MAX_PORT_HOPS} from ${this.config.port || 8080})`);
+  }
+
+  /**
+   * GET our own /api/health over loopback and compare the instance id.
+   * @private
+   */
+  async _verifyOwnPort() {
+    try {
+      const res = await fetch(`http://127.0.0.1:${this.port}/api/health`, { signal: AbortSignal.timeout(3000) });
+      const data = await res.json();
+      return data?.instance === this.instanceId;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Listen on this.port; resolve true when the port is verified ours, false
+   * when another program answers on it (the server is closed again in that
+   * case). Rejects on a real bind error.
+   * @private
+   */
+  _listenAndVerify() {
     return new Promise((resolve, reject) => {
       // Handle bind errors (EADDRINUSE, EACCES, etc.) — must be set BEFORE listen()
       const onError = (error) => {
@@ -7852,6 +7900,13 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       this.server.listen({ port: this.port, host: this.host, exclusive: false }, async () => {
         // Remove the startup error handler; replace with runtime error handler
         this.server.removeListener('error', onError);
+
+        if (!(await this._verifyOwnPort())) {
+          this.logger.error('Another program answers on the port we bound — not ours', { port: this.port, host: this.host });
+          await new Promise((done) => this.server.close(() => done()));
+          resolve(false);
+          return;
+        }
         this.server.on('error', (error) => {
           this.logger.error('HTTP server runtime error:', {
             error: error.message,
@@ -7922,7 +7977,7 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
           await this.testWebSocketServer();
         }, 1000);
 
-        resolve();
+        resolve(true);
       });
     });
   }
@@ -8056,6 +8111,7 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       isRunning: this.isRunning,
       port: this.port,
       host: this.host,
+      instance: this.instanceId,
       connections: this.connections.size,
       sessions: this.sessions.size,
       url: `http://${this.host}:${this.port}`

package/src/services/__tests__/modelQuirks.test.js

@@ -11,11 +11,32 @@ import { mkdtemp, rm, readFile, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import {
-  classifyParamError, ModelQuirkStore, STRIPPABLE_PARAMS,
+  classifyParamError, classifyForcedValue, parseQuirk, ModelQuirkStore, STRIPPABLE_PARAMS, FORCEABLE_PARAMS,
   getModelQuirkStore, _resetModelQuirkStore,
 } from '../modelQuirks.js';
 
 const GPT56_MESSAGE = "400 Unsupported value: 'temperature' does not support 0.7 with this model. Only the default (1) value is supported.";
+// Fixture #2 is the VERBATIM gpt-6-astra rejection (2026-09-06, Azure gateway /llm/chat, function tools on).
+const ASTRA_MESSAGE = "HTTP 400: Bad Request - 400 Function tools with reasoning_effort are not supported for gpt-6-astra in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.";
+
+describe('classifyForcedValue (fixture #2: gpt-6-astra)', () => {
+  test('the astra message names the value to SEND, not a key to strip', () => {
+    expect(classifyForcedValue(new Error(ASTRA_MESSAGE))).toEqual({ param: 'reasoning_effort', value: 'none' });
+    expect(classifyParamError(new Error(ASTRA_MESSAGE))).toBeNull(); // no strippable param in it
+    expect(classifyForcedValue(ASTRA_MESSAGE)).toEqual({ param: 'reasoning_effort', value: 'none' });
+  });
+  test('only forceable params, only rejection messages; strip-class errors stay null', () => {
+    expect(classifyForcedValue(new Error("not supported: set temperature to '1'"))).toBeNull(); // temperature is strippable, not forceable
+    expect(classifyForcedValue(new Error("please set reasoning_effort to 'low'"))).toBeNull(); // no rejection wording
+    expect(classifyForcedValue(new Error(GPT56_MESSAGE))).toBeNull();
+    expect(classifyForcedValue(null)).toBeNull();
+    expect(FORCEABLE_PARAMS).toEqual(['reasoning_effort']);
+  });
+  test('parseQuirk splits forced entries and leaves bare ones', () => {
+    expect(parseQuirk('reasoning_effort=none')).toEqual({ param: 'reasoning_effort', value: 'none' });
+    expect(parseQuirk('temperature')).toEqual({ param: 'temperature', value: undefined });
+  });
+});
 
 describe('classifyParamError', () => {
   test('fixture #1: the gpt-5.6-sol production error (message form)', () => {
@@ -136,6 +157,39 @@ describe('ModelQuirkStore', () => {
     await store.flush(); // in-flight persist must settle before dir cleanup
   });
 
+  test('a forced-value quirk (key=value) is SET by sanitize, persists, and re-applies after reload', async () => {
+    const store = new ModelQuirkStore({});
+    await store.load();
+    expect(store.add('gpt-6-astra', 'reasoning_effort=none')).toBe(true);
+    const payload = { temperature: 0.7, tools: [{}] };
+    expect(store.sanitize('gpt-6-astra', payload)).toEqual(['reasoning_effort']);
+    expect(payload).toEqual({ temperature: 0.7, tools: [{}], reasoning_effort: 'none' });
+    expect(store.sanitize('gpt-6-astra', payload)).toEqual([]); // already in place → nothing touched
+    await store.flush();
+    const again = new ModelQuirkStore({});
+    await again.load();
+    const p2 = {};
+    again.sanitize('gpt-6-astra', p2);
+    expect(p2).toEqual({ reasoning_effort: 'none' });
+    await again.flush();
+  });
+
+  test('a forced quirk can be retired: forcedEntry finds it, remove forgets it and persists', async () => {
+    const store = new ModelQuirkStore({});
+    await store.load();
+    store.add('gpt-6-astra', 'reasoning_effort=none');
+    store.add('gpt-6-astra', 'temperature');
+    expect(store.forcedEntry('gpt-6-astra', 'reasoning_effort')).toBe('reasoning_effort=none');
+    expect(store.forcedEntry('gpt-6-astra', 'temperature')).toBeNull(); // bare strip entry is not a forced value
+    expect(store.remove('gpt-6-astra', 'reasoning_effort=none')).toBe(true);
+    expect(store.remove('gpt-6-astra', 'reasoning_effort=none')).toBe(false);
+    expect([...store.get('gpt-6-astra')]).toEqual(['temperature']);
+    await store.flush();
+    const again = new ModelQuirkStore({});
+    await again.load();
+    expect([...again.get('gpt-6-astra')]).toEqual(['temperature']);
+  });
+
   test('persist failure warns but the quirk stays active in memory', async () => {
     const store = new ModelQuirkStore({ logger: { warn: jest.fn() } });
     await store.load();

package/src/services/__tests__/serviceRegistry.test.js

@@ -11,7 +11,29 @@ jest.unstable_mockModule('../portRegistry.js', () => ({
   }))
 }));
 
-const { ServiceRegistry, ServiceStatus, registry } = await import('../serviceRegistry.js');
+const { ServiceRegistry, ServiceStatus, registry, isPortFree, isWildcardHost } = await import('../serviceRegistry.js');
+const net = await import('node:net');
+
+describe('isPortFree — a wildcard port is free only if loopback is free too (Windows collision)', () => {
+  test('a port held on 127.0.0.1 is NOT free for 0.0.0.0 (the shell connects over loopback); it is free again once released', async () => {
+    const holder = net.createServer();
+    await new Promise((r) => holder.listen(0, '127.0.0.1', r));
+    const port = holder.address().port;
+    try {
+      expect(await isPortFree(port, '127.0.0.1')).toBe(false);
+      expect(await isPortFree(port, '0.0.0.0')).toBe(false); // the bind may succeed on Windows — still not ours
+    } finally {
+      await new Promise((r) => holder.close(r));
+    }
+    expect(await isPortFree(port, '0.0.0.0')).toBe(true);
+    expect(await isPortFree(port, '127.0.0.1')).toBe(true);
+  });
+
+  test('isWildcardHost', () => {
+    for (const h of ['0.0.0.0', '::', '', undefined, null]) expect(isWildcardHost(h)).toBe(true);
+    for (const h of ['127.0.0.1', 'localhost', '::1', '192.168.1.5']) expect(isWildcardHost(h)).toBe(false);
+  });
+});
 
 describe('ServiceRegistry', () => {
   beforeEach(() => {

package/src/services/aiService.js

@@ -16,7 +16,7 @@ import {
   HTTP_STATUS,
   COMPACTION_CONFIG
 } from '../utilities/constants.js';
-import { getModelQuirkStore, classifyParamError, STRIPPABLE_PARAMS } from './modelQuirks.js';
+import { getModelQuirkStore, classifyParamError, classifyForcedValue, STRIPPABLE_PARAMS } from './modelQuirks.js';
 import { getOllamaService, OLLAMA_MODEL_PREFIX } from './ollamaService.js';
 import { getDaniService, DANI_MODEL_PREFIX } from './daniService.js';
 import { SHARED_MEMORY_SCOPE } from './memoryService.js';
@@ -2334,9 +2334,35 @@ class AIService {
    */
   _learnParamQuirk(model, error, payloadOptions) {
     try {
+      if (!payloadOptions) return false;
+      // Forced-value quirk: the provider names the value to send ("set
+      // reasoning_effort to 'none'" — gpt-6-astra with function tools on
+      // chat completions, 2026-09-06). Nothing to strip; set it and retry.
+      const forced = classifyForcedValue(error);
+      if (forced && payloadOptions[forced.param] !== forced.value) {
+        payloadOptions[forced.param] = forced.value;
+        const isNew = this._quirkStore().add(model, `${forced.param}=${forced.value}`);
+        this.logger.warn(
+          `MODEL QUIRK ${isNew ? 'LEARNED' : 'RE-APPLIED'}: ${model} needs '${forced.param}=${forced.value}' — set and retrying once. ` +
+          `Future requests send it (config/model-quirks.json); declare parameters.fixed.${forced.param} on the catalog entry to avoid the first failure.`,
+          { model, param: forced.param, value: forced.value }
+        );
+        return true;
+      }
       const param = classifyParamError(error);
-      if (!param || !STRIPPABLE_PARAMS.includes(param)) return false;
-      if (!payloadOptions || !(param in payloadOptions)) return false;
+      if (!param) return false;
+      // A forced value WE added is now rejected (the catalog re-routed the
+      // model, e.g. gpt-6-astra to the Responses API, where reasoning_effort
+      // is refused): retire the quirk, drop the key, retry once.
+      const forcedEntry = this._quirkStore().forcedEntry(model, param);
+      if (forcedEntry && param in payloadOptions) {
+        delete payloadOptions[param];
+        this._quirkStore().remove(model, forcedEntry);
+        this.logger.warn(`MODEL QUIRK RETIRED: ${model} now rejects '${param}' — forgot '${forcedEntry}', stripped and retrying once.`, { model, param });
+        return true;
+      }
+      if (!STRIPPABLE_PARAMS.includes(param)) return false;
+      if (!(param in payloadOptions)) return false;
       delete payloadOptions[param];
       const isNew = this._quirkStore().add(model, param);
       this.logger.warn(

package/src/services/modelQuirks.js

@@ -70,6 +70,36 @@ function canonicalize(param) {
   return PARAM_ALIASES[p] ?? p;
 }
 
+/** Payload keys a provider may ask us to SET to a specific value (forced quirks). */
+export const FORCEABLE_PARAMS = Object.freeze(['reasoning_effort']);
+
+/**
+ * A rejection that names the value to send instead of stripping a key —
+ * live-caught (2026-09-06, gpt-6-astra via the Azure gateway):
+ *   400 "Function tools with reasoning_effort are not supported for gpt-6-astra
+ *        in /v1/chat/completions. To use function tools, use /v1/responses or
+ *        set reasoning_effort to 'none'."
+ * Azure applies its own non-'none' reasoning default, so there is nothing to
+ * strip; the fix is to SEND the value the provider names. Returns
+ * { param, value } (canonical param) or null.
+ */
+export function classifyForcedValue(error) {
+  if (!error) return null;
+  const msg = String(error.message ?? error);
+  if (!/not supported|unsupported/i.test(msg)) return null;
+  const m = /\bset\s+["']?([\w.]+)["']?\s+to\s+["']([\w.-]+)["']/i.exec(msg) || /\bset\s+["']?([\w.]+)["']?\s+to\s+([\w.-]+)\b/i.exec(msg);
+  if (!m) return null;
+  const param = canonicalize(m[1]);
+  return FORCEABLE_PARAMS.includes(param) ? { param, value: m[2] } : null;
+}
+
+/** Quirk entry encoding: a bare key = strip it; `key=value` = force that value. */
+export function parseQuirk(entry) {
+  const s = String(entry);
+  const i = s.indexOf('=');
+  return i < 0 ? { param: s, value: undefined } : { param: s.slice(0, i), value: s.slice(i + 1) };
+}
+
 /**
  * Per-model quirk memory. `{ models: { "<model>": ["temperature", …] } }`
  * persisted atomically to <dataDir>/config/model-quirks.json.
@@ -117,11 +147,43 @@ export class ModelQuirkStore {
     const set = this._quirks.get(model);
     if (set.has(param)) return false;
     set.add(param);
-    this._persistPromise = this._persist().catch((err) =>
-      this.logger?.warn?.(`[quirks] persist failed (quirk still active this session): ${err.message}`));
+    this._schedulePersist('quirk still active this session');
     return true;
   }
 
+  /**
+   * Persists are chained, never concurrent: two writes racing through the
+   * same temp file + rename could land the OLDER snapshot last (add, add,
+   * remove → reload showed nothing).
+   */
+  _schedulePersist(stillActiveNote) {
+    this._persistPromise = (this._persistPromise || Promise.resolve())
+      .then(() => this._persist())
+      .catch((err) => this.logger?.warn?.(`[quirks] persist failed (${stillActiveNote}): ${err.message}`));
+  }
+
+  /**
+   * Forget a learned quirk (e.g. a forced value the provider later rejects
+   * once the catalog routes the model elsewhere). Returns true when removed.
+   */
+  remove(model, entry) {
+    const set = this._quirks.get(model);
+    if (!set || !set.has(entry)) return false;
+    set.delete(entry);
+    if (!set.size) this._quirks.delete(model);
+    this._schedulePersist('removal still active this session');
+    return true;
+  }
+
+  /** The forced entry (`param=value`) this model carries for `param`, or null. */
+  forcedEntry(model, param) {
+    for (const entry of this.get(model)) {
+      const q = parseQuirk(entry);
+      if (q.param === param && q.value !== undefined) return entry;
+    }
+    return null;
+  }
+
   /** Await any in-flight persist (graceful shutdown / tests). */
   async flush() {
     await this._persistPromise;
@@ -138,19 +200,23 @@ export class ModelQuirkStore {
   }
 
   /**
-   * Remove known-rejected keys from a payload options object IN PLACE
-   * (payloads are request-local). Returns the list of stripped keys.
+   * Apply this model's quirks to a payload options object IN PLACE
+   * (payloads are request-local): bare entries are removed, `key=value`
+   * entries are set. Returns the list of touched keys.
    */
   sanitize(model, payloadOptions) {
-    const stripped = [];
-    if (!payloadOptions || typeof payloadOptions !== 'object') return stripped;
-    for (const param of this.get(model)) {
-      if (param in payloadOptions) {
+    const touched = [];
+    if (!payloadOptions || typeof payloadOptions !== 'object') return touched;
+    for (const entry of this.get(model)) {
+      const { param, value } = parseQuirk(entry);
+      if (value !== undefined) {
+        if (payloadOptions[param] !== value) { payloadOptions[param] = value; touched.push(param); }
+      } else if (param in payloadOptions) {
         delete payloadOptions[param];
-        stripped.push(param);
+        touched.push(param);
       }
     }
-    return stripped;
+    return touched;
   }
 }
 

package/src/services/serviceRegistry.js

@@ -318,7 +318,27 @@ export async function findFreePort(preferredPort, maxAttempts = 100, host = '127
  * @param {string} host - Host to check (default: '127.0.0.1')
  * @returns {Promise<boolean>}
  */
+/** '0.0.0.0' / '::' / empty = bind every interface. */
+export function isWildcardHost(host) {
+  return host === undefined || host === null || host === '' || host === '0.0.0.0' || host === '::';
+}
+
 export async function isPortFree(port, host = '127.0.0.1') {
+  // A wildcard bind is NOT proof the port is free on Windows: binding 0.0.0.0:P
+  // succeeds while another program holds 127.0.0.1:P, and every connection to
+  // localhost:P then reaches THAT program (measured 2026-09-06: llama-server on
+  // 127.0.0.1:8080, our 0.0.0.0:8080 bind "worked", the Electron shell polled
+  // /api/health against llama-server for 30 attempts → "Backend did not become
+  // healthy"). The shell, the UI and the relay all connect via loopback, so a
+  // wildcard port is free only if loopback is free too.
+  if (isWildcardHost(host)) {
+    const loopbackFree = await bindProbe(port, '127.0.0.1');
+    if (!loopbackFree) return false;
+  }
+  return bindProbe(port, host);
+}
+
+async function bindProbe(port, host) {
   return new Promise((resolve) => {
     const server = net.createServer();