@fonoster/amd 0.25.1 → 0.25.2

package/dist/agi/server.d.ts

@@ -8,10 +8,9 @@ import { AgiServer } from "./AgiServer";
  * however many channel variables that mode produces, SET each, then return
  * so the dialplan resumes at Stasis(mediacontroller).
  *
- * Always fail-open: a `setTimeout` bounds the whole session even if the
- * AudioSocket side never resolves, and a top-level try/catch guarantees the
- * SET VARIABLE commands are still attempted before the handler returns — an
- * exception must never leave the AGI connection hanging.
+ * Always fail-open: deadlines bound both the wait for a verdict and the wait
+ * for AudioSocket() to return, and the AGI connection is always closed so the
+ * dialplan resumes even when no variables could be set.
  */
 declare function startAgiServer(): AgiServer;
 export { startAgiServer };

package/dist/agi/server.js

@@ -40,6 +40,11 @@ const TIMED_OUT_RESULT = () => ({
     cause: "ML-TIMEOUT",
     latencyMs: 0
 });
+// How long to wait, once the verdict is in, for AudioSocket() to return and
+// free the AGI socket. The audio leg hangs up right after classifying and
+// runProbe shares TIMEOUT_MS, so this only runs out on a genuinely stuck leg.
+const AUDIOSOCKET_RELEASE_MS = 2000;
+const delay = (ms, value) => new Promise((resolve) => setTimeout(() => resolve(value), ms));
 /**
  * Starts the FastAGI listener. Asterisk's `AGI(agi://amd:4573,${AMD_MODE})`
  * blocks the channel here. Per session: read the requested mode from the
@@ -49,10 +54,9 @@ const TIMED_OUT_RESULT = () => ({
  * however many channel variables that mode produces, SET each, then return
  * so the dialplan resumes at Stasis(mediacontroller).
  *
- * Always fail-open: a `setTimeout` bounds the whole session even if the
- * AudioSocket side never resolves, and a top-level try/catch guarantees the
- * SET VARIABLE commands are still attempted before the handler returns — an
- * exception must never leave the AGI connection hanging.
+ * Always fail-open: deadlines bound both the wait for a verdict and the wait
+ * for AudioSocket() to return, and the AGI connection is always closed so the
+ * dialplan resumes even when no variables could be set.
  */
 function startAgiServer() {
     const agi = new AgiServer_1.AgiServer({ port: envs_1.AGI_PORT });
@@ -71,39 +75,57 @@ function startAgiServer() {
             (0, sessionRegistry_1.unregisterPendingClassification)(sessionId);
         });
         logger.verbose("agi call", { sessionId, mode, channel: call.channel });
-        const timeout = new Promise((resolve) => {
-            setTimeout(() => resolve(TIMED_OUT_RESULT()), envs_1.TIMEOUT_MS);
-        });
-        // Wrapped as one promise so the deadline bounds the EXEC itself, not just
-        // the wait that follows it — otherwise a stuck/unreachable AudioSocket
-        // connection would hang here forever before the race below is ever
-        // reached, despite the fail-open guarantee described above.
-        const work = (() => __awaiter(this, void 0, void 0, function* () {
-            const pending = (0, sessionRegistry_1.registerPendingClassification)(sessionId);
-            yield call.exec("AudioSocket", `${sessionId},${envs_1.AUDIOSOCKET_ADVERTISE_HOST}:${envs_1.AUDIOSOCKET_PORT}`);
-            return pending;
-        }))();
-        work.catch(() => undefined); // no unhandled rejection if the deadline wins
-        let result;
-        try {
-            result = yield Promise.race([work, timeout]);
-        }
-        catch (err) {
-            logger.warn("agi session failed; reporting unknown", {
+        const classification = (0, sessionRegistry_1.registerPendingClassification)(sessionId);
+        // AudioSocket()'s result says nothing about whether AMD worked: Asterisk
+        // before 20.14 returns -1 ("200 result=-1") whenever the remote ends the
+        // stream, including the HANGUP this server sends after every
+        // classification. It only tells us when the leg is over and the AGI
+        // socket is free again.
+        const legEnded = call
+            .exec("AudioSocket", `${sessionId},${envs_1.AUDIOSOCKET_ADVERTISE_HOST}:${envs_1.AUDIOSOCKET_PORT}`)
+            .catch((err) => {
+            logger.verbose("AudioSocket() returned", {
                 sessionId,
-                error: err.message
+                result: err.message
+            });
+        });
+        // The verdict is resolved in-process before the audio leg hangs up, so a
+        // leg that ends first (e.g. Asterisk couldn't connect) has no verdict.
+        const noVerdict = {
+            kind: "unknown",
+            cause: "ML-ERROR",
+            latencyMs: 0
+        };
+        const result = yield Promise.race([
+            classification,
+            legEnded.then(() => noVerdict),
+            delay(envs_1.TIMEOUT_MS, TIMED_OUT_RESULT())
+        ]);
+        (0, sessionRegistry_1.unregisterPendingClassification)(sessionId);
+        if (result === noVerdict) {
+            logger.warn("audiosocket leg ended without a verdict; reporting unknown", {
+                sessionId
             });
-            result = { kind: "unknown", cause: "ML-ERROR", latencyMs: 0 };
-        }
-        finally {
-            (0, sessionRegistry_1.unregisterPendingClassification)(sessionId);
         }
+        // FastAGI is one command at a time: SET VARIABLE can only be sent once
+        // AudioSocket() has returned.
+        const released = yield Promise.race([
+            legEnded.then(() => true),
+            delay(AUDIOSOCKET_RELEASE_MS, false)
+        ]);
         if (hungUp || call.hungup) {
             logger.verbose("agi call hung up mid-analysis; skipping SET VARIABLE", {
                 sessionId
             });
             return;
         }
+        if (!released) {
+            logger.warn("audiosocket leg still open; skipping SET VARIABLE", {
+                sessionId
+            });
+            call.close();
+            return;
+        }
         const variables = (0, buildAmdVariables_1.buildAmdVariables)(result, mode, envs_1.MIN_CONFIDENCE);
         logger.verbose("agi call variables", { sessionId, mode, variables });
         try {

package/dist/probe/collectPcm.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectPcm = collectPcm;
-const SAMPLE_RATE = 16000;
+// Asterisk's AudioSocket() app always streams slin (8 kHz), whatever the
+// channel's native rate.
+const SAMPLE_RATE = 8000;
 const BYTES_PER_SAMPLE = 2; // mono, 16-bit little-endian
 /**
  * Buffers the first `probeMs` of a call's audio (or whatever arrives before

package/dist/probe/runProbe.js

@@ -31,6 +31,7 @@ exports.runProbe = runProbe;
 const logger_1 = require("@fonoster/logger");
 const AmdModel_1 = require("../amd/AmdModel");
 const collectPcm_1 = require("./collectPcm");
+const upsample_1 = require("./upsample");
 const logger = (0, logger_1.getLogger)({ service: "amd", filePath: __filename });
 /**
  * Runs Answering Machine Detection on the leading audio of one AGI/AudioSocket
@@ -79,7 +80,8 @@ function runProbe(params) {
             // The deadline must also bound classification: a cold model load or a hung
             // inference cannot be allowed to stall the AGI session. ONNX Runtime has no
             // cancellation, so the losing promise is left to settle on its own.
-            const classification = classify(pcm);
+            // The model was trained on 16 kHz input; AudioSocket delivers 8 kHz.
+            const classification = classify((0, upsample_1.upsample8kTo16k)(pcm));
             classification.catch(() => undefined); // no unhandled rejection if the deadline wins
             const outcome = yield Promise.race([classification, onDeadline]);
             if (outcome === TIMED_OUT) {

package/dist/probe/upsample.d.ts

@@ -0,0 +1,3 @@
+/** Upsamples 8 kHz s16le mono PCM to 16 kHz s16le mono. */
+declare function upsample8kTo16k(pcm: Buffer): Buffer;
+export { upsample8kTo16k };

package/dist/probe/upsample.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsample8kTo16k = upsample8kTo16k;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const HALF_TAPS = 16;
+// Half-band windowed-sinc (Blackman) taps at offsets ±(k + 0.5), normalized
+// to unity DC gain. Linear interpolation measurably loses accuracy here: its
+// imaging above 4 kHz is enough to lower the classifier's confidence.
+const TAPS = (() => {
+    const taps = new Float64Array(HALF_TAPS);
+    let sum = 0;
+    for (let k = 0; k < HALF_TAPS; k++) {
+        const offset = k + 0.5;
+        const sinc = Math.sin(Math.PI * offset) / (Math.PI * offset);
+        const u = (offset + HALF_TAPS) / (2 * HALF_TAPS);
+        const window = 0.42 - 0.5 * Math.cos(2 * Math.PI * u) + 0.08 * Math.cos(4 * Math.PI * u);
+        taps[k] = sinc * window;
+        sum += 2 * taps[k];
+    }
+    return taps.map((t) => t / sum);
+})();
+/** Upsamples 8 kHz s16le mono PCM to 16 kHz s16le mono. */
+function upsample8kTo16k(pcm) {
+    const count = Math.floor(pcm.length / 2);
+    const out = Buffer.alloc(count * 4);
+    const sample = (i) => pcm.readInt16LE(2 * Math.min(Math.max(i, 0), count - 1));
+    for (let i = 0; i < count; i++) {
+        let interpolated = 0;
+        for (let k = 0; k < HALF_TAPS; k++) {
+            interpolated += TAPS[k] * (sample(i - k) + sample(i + 1 + k));
+        }
+        out.writeInt16LE(pcm.readInt16LE(2 * i), 4 * i);
+        out.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(interpolated))), 4 * i + 2);
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/amd",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "description": "Standalone answering-machine-detection sidecar for the Fonoster platform",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
@@ -21,7 +21,7 @@
   "dependencies": {
     "@fonoster/common": "^0.25.1",
     "@fonoster/logger": "^0.25.0",
-    "@fonoster/streams": "^0.25.0",
+    "@fonoster/streams": "^0.25.2",
     "@fonoster/types": "^0.25.0",
     "onnxruntime-node": "1.21.1",
     "uuid": "^11.0.3"
@@ -43,5 +43,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/fonoster/issues"
   },
-  "gitHead": "7a3786a2704ae379211fbd350a3f6e8d913a5fd6"
+  "gitHead": "6a1a458326108fd79f670c5b0470f15d957ae867"
 }