@fonoster/amd 0.27.0 → 0.31.0

package/dist/agi/server.js

@@ -1,154 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startAgiServer = startAgiServer;
-/**
- * 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 logger_1 = require("@fonoster/logger");
-const uuid_1 = require("uuid");
-const buildAmdVariables_1 = require("../amd/buildAmdVariables");
-const envs_1 = require("../envs");
-const AgiServer_1 = require("./AgiServer");
-const sessionRegistry_1 = require("./sessionRegistry");
-const logger = (0, logger_1.getLogger)({ service: "amd", filePath: __filename });
-const TIMED_OUT_RESULT = () => ({
-    kind: "unknown",
-    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
- * dialplan's first AGI argument (`compact`, the default, or `full`), mint a
- * UUID, EXEC AudioSocket to pull the leading audio (blocks until the
- * AudioSocket side hangs up), await the correlated raw result, map it to
- * however many channel variables that mode produces, SET each, then return
- * so the dialplan resumes at Stasis(mediacontroller).
- *
- * 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 });
-    agi.on("ready", (port) => {
-        logger.info("agi server listening", { port });
-    });
-    agi.on("error", (err) => {
-        logger.error("agi server error", err);
-    });
-    agi.on("call", (call) => __awaiter(this, void 0, void 0, function* () {
-        const sessionId = (0, uuid_1.v4)();
-        const mode = (0, buildAmdVariables_1.parseMode)(call.args[0]);
-        let hungUp = false;
-        call.once("hangup", () => {
-            hungUp = true;
-            (0, sessionRegistry_1.unregisterPendingClassification)(sessionId);
-        });
-        logger.verbose("agi call", { sessionId, mode, channel: call.channel });
-        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,
-                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
-            });
-        }
-        // 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 {
-            // Sequential, not Promise.all: AgiChannel allows only one command in
-            // flight on the AGI socket at a time.
-            for (const [name, value] of Object.entries(variables)) {
-                yield call.setVariable(name, value);
-            }
-        }
-        catch (err) {
-            logger.warn("failed to set AMD channel variables", {
-                sessionId,
-                error: err.message
-            });
-        }
-        finally {
-            // Asterisk's AGI() app returns control to the dialplan when the AGI
-            // script closes the connection — not on any special "done" command.
-            // Always close, success or failure, or the channel would sit in
-            // AGI() forever.
-            if (!call.hungup)
-                call.close();
-        }
-    }));
-    return agi;
-}

package/dist/agi/sessionRegistry.d.ts

@@ -1,26 +0,0 @@
-/**
- * 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.
- */
-import { ProbeResult } from "../probe/runProbe";
-/** Called by the AGI handler right before it EXECs AudioSocket(). */
-declare function registerPendingClassification(sessionId: string): Promise<ProbeResult>;
-/** Called by the AudioSocket connection handler once it has a result. */
-declare function resolvePendingClassification(sessionId: string, result: ProbeResult): void;
-/** Called by the AGI handler in its `finally`, in case nothing ever resolved it. */
-declare function unregisterPendingClassification(sessionId: string): void;
-export { registerPendingClassification, resolvePendingClassification, unregisterPendingClassification };

package/dist/agi/sessionRegistry.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPendingClassification = registerPendingClassification;
-exports.resolvePendingClassification = resolvePendingClassification;
-exports.unregisterPendingClassification = unregisterPendingClassification;
-/**
- * In-memory correlation between an AGI session and the AudioSocket connection
- * it spawns, keyed by the UUID the AGI handler mints and passes as the
- * AudioSocket() argument. Both listeners live in the same process, so this is
- * a plain Map rather than anything cross-process.
- *
- * Carries the raw, mode-agnostic ProbeResult — not yet mapped to channel
- * variables, since only the AGI side knows which mode (compact/full) this
- * session asked for.
- */
-const pending = new Map();
-/** Called by the AGI handler right before it EXECs AudioSocket(). */
-function registerPendingClassification(sessionId) {
-    return new Promise((resolve) => {
-        pending.set(sessionId, { resolve });
-    });
-}
-/** Called by the AudioSocket connection handler once it has a result. */
-function resolvePendingClassification(sessionId, result) {
-    const entry = pending.get(sessionId);
-    if (!entry)
-        return;
-    pending.delete(sessionId);
-    entry.resolve(result);
-}
-/** Called by the AGI handler in its `finally`, in case nothing ever resolved it. */
-function unregisterPendingClassification(sessionId) {
-    pending.delete(sessionId);
-}

package/dist/amd/buildAmdVariables.d.ts

@@ -1,13 +0,0 @@
-import { ProbeResult } from "../probe/runProbe";
-type AmdMode = "compact" | "full";
-type AmdVariables = Record<string, string>;
-/**
- * Parses the mode passed as the AGI session's first dialplan argument (e.g.
- * `AGI(agi://amd:4573,${AMD_MODE})` -> `agi_arg_1` -> here).
- * Anything but the literal "full" is treated as "compact" — the safe,
- * native-AMD-compatible default when the argument is absent, empty, or
- * misspelled.
- */
-declare function parseMode(raw: string | undefined): AmdMode;
-declare function buildAmdVariables(result: ProbeResult, mode: AmdMode, minConfidence: number): AmdVariables;
-export { AmdMode, AmdVariables, buildAmdVariables, parseMode };

package/dist/amd/buildAmdVariables.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildAmdVariables = buildAmdVariables;
-exports.parseMode = parseMode;
-/**
- * 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 common_1 = require("@fonoster/common");
-/**
- * Parses the mode passed as the AGI session's first dialplan argument (e.g.
- * `AGI(agi://amd:4573,${AMD_MODE})` -> `agi_arg_1` -> here).
- * Anything but the literal "full" is treated as "compact" — the safe,
- * native-AMD-compatible default when the argument is absent, empty, or
- * misspelled.
- */
-function parseMode(raw) {
-    return raw === "full" ? "full" : "compact";
-}
-/**
- * Collapses the classifier's 5-way AmdStatus onto the 4-way AMDSTATUS
- * vocabulary Asterisk's own AMD() app uses (HUMAN/MACHINE/NOTSURE/HANGUP —
- * this module never reports HANGUP, that's apiserver's read of a channel
- * that is already gone). This is the seam that lets apiserver's
- * `mapAsteriskAmd.ts` and `createCreateVoiceClient.ts` stay unmodified: in
- * compact mode they only ever see the same four values native AMD() already
- * produces. Confidence, detector, latency, and the VOICEMAIL/IVR distinction
- * are discarded here — that's exactly what "full" mode below is for.
- */
-function buildCompactVariables(result, minConfidence) {
-    if (result.kind === "unknown") {
-        return { AMDSTATUS: "NOTSURE", AMDCAUSE: result.cause };
-    }
-    if (result.confidence < minConfidence) {
-        return { AMDSTATUS: "NOTSURE", AMDCAUSE: "ML-LOW-CONFIDENCE" };
-    }
-    switch (result.status) {
-        case common_1.AmdStatus.HUMAN:
-            return { AMDSTATUS: "HUMAN", AMDCAUSE: "HUMAN" };
-        case common_1.AmdStatus.MACHINE:
-            return { AMDSTATUS: "MACHINE", AMDCAUSE: "MACHINE-MACHINE" };
-        case common_1.AmdStatus.VOICEMAIL:
-            return { AMDSTATUS: "MACHINE", AMDCAUSE: "MACHINE-VOICEMAIL" };
-        case common_1.AmdStatus.IVR:
-            return { AMDSTATUS: "MACHINE", AMDCAUSE: "MACHINE-IVR" };
-        default:
-            // Reached only when the classifier itself reports UNKNOWN/UNSPECIFIED
-            // — a label AmdModel's mapLabelToStatus didn't recognize — which is
-            // independent of (and must not be confused with) the confidence-
-            // threshold downgrade above: that one already returned by this point.
-            return { AMDSTATUS: "NOTSURE", AMDCAUSE: "ML-UNKNOWN-LABEL" };
-    }
-}
-/**
- * Reports the classifier's own vocabulary and every measurement it
- * produced, untouched (no confidence thresholding) — a consumer that opted
- * into "full" mode is expected to apply its own policy over AMDCONFIDENCE
- * rather than have this module decide NOTSURE for it. Not native-AMD
- * compatible: a consumer reading AMDSTATUS here must expect VOICEMAIL/IVR/
- * UNKNOWN in addition to HUMAN/MACHINE.
- */
-function buildFullVariables(result) {
-    if (result.kind === "unknown") {
-        return {
-            AMDSTATUS: "UNKNOWN",
-            AMDCAUSE: result.cause,
-            AMDCONFIDENCE: "0",
-            AMDDETECTOR: "",
-            AMDLATENCYMS: String(result.latencyMs)
-        };
-    }
-    return {
-        AMDSTATUS: result.status,
-        AMDCAUSE: result.status,
-        AMDCONFIDENCE: result.confidence.toFixed(4),
-        AMDDETECTOR: result.detector,
-        AMDLATENCYMS: String(result.latencyMs)
-    };
-}
-function buildAmdVariables(result, mode, minConfidence) {
-    return mode === "full"
-        ? buildFullVariables(result)
-        : buildCompactVariables(result, minConfidence);
-}

package/dist/audiosocket/server.d.ts

@@ -1,9 +0,0 @@
-import { AudioSocket } from "@fonoster/streams";
-/**
- * Starts the AudioSocket listener that receives the audio leg of each AGI
- * session. Asterisk's `EXEC AudioSocket <uuid>,<host>:<port>` connects here;
- * `req.ref` carries the same UUID the AGI handler minted, correlating this
- * connection with the pending classification it's waiting on.
- */
-declare function startAudioSocketServer(): AudioSocket;
-export { startAudioSocketServer };

package/dist/audiosocket/server.js

@@ -1,65 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startAudioSocketServer = startAudioSocketServer;
-/**
- * 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 logger_1 = require("@fonoster/logger");
-const streams_1 = require("@fonoster/streams");
-const sessionRegistry_1 = require("../agi/sessionRegistry");
-const envs_1 = require("../envs");
-const runProbe_1 = require("../probe/runProbe");
-const logger = (0, logger_1.getLogger)({ service: "amd", filePath: __filename });
-/**
- * Starts the AudioSocket listener that receives the audio leg of each AGI
- * session. Asterisk's `EXEC AudioSocket <uuid>,<host>:<port>` connects here;
- * `req.ref` carries the same UUID the AGI handler minted, correlating this
- * connection with the pending classification it's waiting on.
- */
-function startAudioSocketServer() {
-    const audioSocket = new streams_1.AudioSocket();
-    audioSocket.onConnection((req, stream) => __awaiter(this, void 0, void 0, function* () {
-        const sessionId = req.ref;
-        logger.verbose("audiosocket connection", { sessionId });
-        const result = yield (0, runProbe_1.runProbe)({
-            stream,
-            probeMs: envs_1.PROBE_MS,
-            timeoutMs: envs_1.TIMEOUT_MS,
-            modelDir: envs_1.MODEL_PATH || undefined
-        });
-        logger.verbose("audiosocket result", Object.assign({ sessionId }, result));
-        (0, sessionRegistry_1.resolvePendingClassification)(sessionId, result);
-        stream.hangup();
-    }));
-    audioSocket.listen(envs_1.AUDIOSOCKET_PORT, envs_1.AUDIOSOCKET_BIND_ADDR, () => {
-        logger.info("audiosocket server listening", {
-            port: envs_1.AUDIOSOCKET_PORT,
-            bind: envs_1.AUDIOSOCKET_BIND_ADDR
-        });
-    });
-    return audioSocket;
-}

package/dist/envs.d.ts

@@ -1,8 +0,0 @@
-export declare const AGI_PORT: number;
-export declare const AUDIOSOCKET_PORT: number;
-export declare const AUDIOSOCKET_BIND_ADDR: string;
-export declare const AUDIOSOCKET_ADVERTISE_HOST: string;
-export declare const PROBE_MS: number;
-export declare const TIMEOUT_MS: number;
-export declare const MIN_CONFIDENCE: number;
-export declare const MODEL_PATH: string;

package/dist/envs.js

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODEL_PATH = exports.MIN_CONFIDENCE = exports.TIMEOUT_MS = exports.PROBE_MS = exports.AUDIOSOCKET_ADVERTISE_HOST = exports.AUDIOSOCKET_BIND_ADDR = exports.AUDIOSOCKET_PORT = exports.AGI_PORT = void 0;
-/**
- * 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 path_1 = require("path");
-const dotenv_1 = __importDefault(require("dotenv"));
-if (process.env.NODE_ENV === "development") {
-    dotenv_1.default.config({ path: (0, path_1.join)(__dirname, "..", "..", "..", ".env") });
-}
-const e = process.env;
-// A malformed AMD_* number must not silently break the probe (NaN
-// thresholds disable the deadline / confidence gate), so fall back to the
-// default.
-const positiveInt = (raw, fallback) => {
-    const n = parseInt(raw !== null && raw !== void 0 ? raw : "", 10);
-    return Number.isFinite(n) && n > 0 ? n : fallback;
-};
-const unitFloat = (raw, fallback) => {
-    const n = parseFloat(raw !== null && raw !== void 0 ? raw : "");
-    return Number.isFinite(n) && n >= 0 && n <= 1 ? n : fallback;
-};
-// FastAGI listener. AgiServer binds all interfaces; there is no separate
-// bind-address knob.
-exports.AGI_PORT = positiveInt(e.AMD_AGI_PORT, 4573);
-// AudioSocket listener that receives the probed call audio.
-exports.AUDIOSOCKET_PORT = positiveInt(e.AMD_AUDIOSOCKET_PORT, 9092);
-exports.AUDIOSOCKET_BIND_ADDR = e.AMD_AUDIOSOCKET_BIND_ADDR || "0.0.0.0";
-// The host:port Asterisk is told to connect to for the AudioSocket leg — must
-// be reachable FROM Asterisk, which is why this is separate from the bind
-// address above (e.g. the compose service name, not 0.0.0.0).
-exports.AUDIOSOCKET_ADVERTISE_HOST = e.AMD_AUDIOSOCKET_ADVERTISE_HOST || "amd";
-// Leading audio to gather before classifying, in milliseconds.
-exports.PROBE_MS = positiveInt(e.AMD_PROBE_MS, 3000);
-// Hard deadline for one whole AGI session (buffering + classify + SET
-// VARIABLE). On expiry the verdict is NOTSURE/ML-TIMEOUT.
-exports.TIMEOUT_MS = positiveInt(e.AMD_TIMEOUT_MS, 4000);
-// Verdicts below this confidence are downgraded to NOTSURE.
-exports.MIN_CONFIDENCE = unitFloat(e.AMD_MIN_CONFIDENCE, 0.8);
-// Override the model directory (model.onnx / mel_filters.bin / meta.json).
-// Empty string -> the copy bundled with @fonoster/amd.
-exports.MODEL_PATH = e.AMD_MODEL_PATH || "";

package/dist/probe/collectPcm.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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.
- */
-import { AudioStream } from "@fonoster/streams";
-type CollectPcmParams = {
-    stream: AudioStream;
-    probeMs: number;
-    signal: AbortSignal;
-};
-/**
- * Buffers the first `probeMs` of a call's audio (or whatever arrives before
- * the shared deadline) off an AudioSocket `AudioStream` and returns it as one
- * Buffer. Resolves early once enough audio has accumulated, on the stream
- * closing/erroring, or when `signal` aborts. Never rejects.
- *
- * `AudioStream` exposes no way to remove a single listener, so this settles
- * once via a guard flag rather than detaching — safe here because each
- * AudioStream is scoped to one AGI/AudioSocket session and is torn down right
- * after classification (see `audiosocket/server.ts`).
- */
-declare function collectPcm(params: CollectPcmParams): Promise<Buffer>;
-export { collectPcm };

package/dist/probe/collectPcm.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectPcm = collectPcm;
-// 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
- * the shared deadline) off an AudioSocket `AudioStream` and returns it as one
- * Buffer. Resolves early once enough audio has accumulated, on the stream
- * closing/erroring, or when `signal` aborts. Never rejects.
- *
- * `AudioStream` exposes no way to remove a single listener, so this settles
- * once via a guard flag rather than detaching — safe here because each
- * AudioStream is scoped to one AGI/AudioSocket session and is torn down right
- * after classification (see `audiosocket/server.ts`).
- */
-function collectPcm(params) {
-    const { stream, probeMs, signal } = params;
-    const bytesNeeded = Math.ceil((probeMs / 1000) * SAMPLE_RATE * BYTES_PER_SAMPLE);
-    return new Promise((resolve) => {
-        const chunks = [];
-        let total = 0;
-        let settled = false;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(windowTimer);
-            signal.removeEventListener("abort", finish);
-            resolve(Buffer.concat(chunks, total));
-        };
-        stream.onData((chunk) => {
-            if (settled)
-                return;
-            chunks.push(chunk);
-            total += chunk.length;
-            if (total >= bytesNeeded)
-                finish();
-        });
-        stream.onClose(finish);
-        stream.onError(finish);
-        const windowTimer = setTimeout(finish, probeMs);
-        signal.addEventListener("abort", finish, { once: true });
-    });
-}

package/dist/probe/runProbe.d.ts

@@ -1,37 +0,0 @@
-import { AudioStream } from "@fonoster/streams";
-import { AmdClassification } from "../amd/AmdModel";
-type Classify = (pcm: Buffer) => Promise<AmdClassification>;
-type RunProbeParams = {
-    stream: AudioStream;
-    probeMs: number;
-    timeoutMs: number;
-    modelDir?: string;
-    classify?: Classify;
-};
-/**
- * Raw, mode-agnostic outcome of one probe — the classifier's own status
- * vocabulary (HUMAN/MACHINE/VOICEMAIL/IVR/UNKNOWN) with confidence, detector,
- * and latency untouched. What this becomes on the wire (compact, native-
- * vocabulary channel vars vs. the full range) is a policy decision made by
- * `buildAmdVariables`, not here — this function only measures.
- */
-type ProbeResult = {
-    kind: "classified";
-    status: AmdClassification["status"];
-    confidence: number;
-    detector: string;
-    latencyMs: number;
-} | {
-    kind: "unknown";
-    cause: string;
-    latencyMs: number;
-};
-/**
- * Runs Answering Machine Detection on the leading audio of one AGI/AudioSocket
- * session. Always resolves and never throws: any model error, timeout, or
- * empty capture yields `{ kind: "unknown" }` so the caller can always report
- * *something* back over AGI. Confidence thresholding is deliberately not
- * applied here — see `buildAmdVariables`.
- */
-declare function runProbe(params: RunProbeParams): Promise<ProbeResult>;
-export { ProbeResult, runProbe, RunProbeParams };