@fonoster/amd 0.30.0 → 0.31.0

package/README.md

@@ -1,91 +1,19 @@
 amd
 =================
 
-Standalone Answering Machine Detection sidecar for Fonoster. Runs an ONNX
-whisper-tiny classifier over the leading audio of an outbound call and
-reports the verdict onto the same `AMDSTATUS`/`AMDCAUSE` Asterisk channel
-variables that Asterisk's own native `AMD()` application sets — so nothing
-downstream (`apiserver`'s `createCreateVoiceClient.ts` / `mapAsteriskAmd.ts`)
-needs to change to consume it.
+Answering-machine detection for Fonoster. An ONNX whisper-tiny classifier reads the first seconds
+of a call's audio and returns a status (HUMAN, MACHINE, VOICEMAIL, IVR or UNKNOWN), a confidence,
+the detector name and the latency.
 
-It runs as its own process/container, decoupled from `apiserver` and
-`autopilot`, and can be built, tested, and smoke-tested against a bare
-Asterisk box with no other part of the Fonoster stack running.
+AppBridge loads it for the `amd` listener: it attaches a listen-only participant to the room,
+collects the caller's audio (16 kHz L16) and calls `classifyPcm`. The model ships with the package
+in `amd-model/`.
 
-## How it works
+```ts
+import { classifyPcm } from "@fonoster/amd";
 
-1. The dialplan (see `asterisk/config/extensions.conf`'s `AMD_ENGINE` gate)
-   calls `AGI(agi://amd:4573,${AMD_MODE})`, which blocks the channel.
-   The argument is the mode feature flag — see below.
-2. Inside that AGI session, this service mints a UUID and runs
-   `EXEC AudioSocket <uuid>,<host>:<port>`, which blocks until the AudioSocket
-   side (a second listener in this same process) closes the connection.
-3. The AudioSocket side buffers a few seconds of PCM and classifies it with
-   the bundled ONNX model — always the classifier's own five-way status
-   (HUMAN/MACHINE/VOICEMAIL/IVR/UNKNOWN) plus confidence, detector, and
-   latency; nothing is thrown away yet — then hangs up, which unblocks the
-   AGI session.
-4. The AGI session maps that raw result to channel variables according to
-   the requested mode (see below), issues one `SET VARIABLE` per variable
-   over the same AGI connection, then closes the connection — which is what
-   tells Asterisk's `AGI()` app to resume the dialplan into
-   `Stasis(mediacontroller)`, exactly as it does today.
-
-Every step is fail-open: a missing/corrupt model, a hung inference, a
-timeout, or empty audio all resolve to an "unknown" result with a diagnostic
-cause (`ML-TIMEOUT`, `ML-ERROR`, `ML-NO-AUDIO`) rather than stalling or
-dropping the call.
-
-## Modes: compact vs. full
-
-The mode is a feature flag passed as the AGI call's first dialplan argument
-(`agi_arg_1` on the wire) — not an env var, since it's a per-call decision
-made in the dialplan, mirroring how `AMD_ENGINE` is already threaded through
-as a channel variable.
-
-- **`compact`** (the default — anything other than the literal `full`,
-  including no argument at all, falls back to this): collapses the
-  classifier's five-way status onto the same four-value `AMDSTATUS`
-  vocabulary Asterisk's native `AMD()` uses (`HUMAN`/`MACHINE`/`NOTSURE`),
-  with `VOICEMAIL`/`IVR` folded into `MACHINE` and a descriptive `AMDCAUSE`
-  (e.g. `MACHINE-VOICEMAIL`). Confidence below `AMD_MIN_CONFIDENCE`
-  is downgraded to `NOTSURE`/`ML-LOW-CONFIDENCE`. Only ever sets
-  `AMDSTATUS`/`AMDCAUSE` — a consumer built against native AMD() sees no
-  difference switching engines.
-- **`full`**: sets `AMDSTATUS` to the classifier's own status
-  (`HUMAN`/`MACHINE`/`VOICEMAIL`/`IVR`/`UNKNOWN`, untouched by any
-  confidence threshold — the consumer applies its own policy), plus
-  `AMDCONFIDENCE` (0–1), `AMDDETECTOR` (model name), and `AMDLATENCYMS`.
-
-Set it from the dialplan by giving `AMD_MODE` a value before the `AGI()`
-call — apiserver already does this for API-originated calls via
-`amd.mode` in `fonoster.yaml` (see below).
-
-## Configuration
-
-The sidecar reads these from its container environment only; it never loads a
-`.env` file, in development either. Set them in the container's environment
-(Compose `environment:`, a Kubernetes `env:`), or export them before
-`npm run start:dev`.
-
-| env | default | meaning |
-|---|---|---|
-| `AMD_AGI_PORT` | `4573` | FastAGI listener port |
-| `AMD_AUDIOSOCKET_PORT` | `9092` | AudioSocket listener port |
-| `AMD_AUDIOSOCKET_BIND_ADDR` | `0.0.0.0` | AudioSocket listener bind address |
-| `AMD_AUDIOSOCKET_ADVERTISE_HOST` | `amd` | host Asterisk is told to connect to for the AudioSocket leg — must be reachable *from* Asterisk |
-| `AMD_PROBE_MS` | `3000` | leading audio to gather before classifying |
-| `AMD_TIMEOUT_MS` | `4000` | hard deadline for the whole AGI session |
-| `AMD_MIN_CONFIDENCE` | `0.8` | compact mode only: verdicts below this are reported as `NOTSURE` |
-| `AMD_MODEL_PATH` | *(bundled)* | override the model directory |
-
-## Enabling it end-to-end
-
-Set `amd.enabled: true` and `amd.engine: ml` in the API server's
-`config/fonoster.yaml`. With the engine unset or set to anything but `ml`,
-behavior is unchanged from Asterisk's native `AMD()`. Additionally set
-`amd.mode: full` to opt into the richer variable set — omit it (or leave it
-`compact`) to stay native-AMD-compatible.
+const verdict = await classifyPcm(pcm);
+```
 
 ## Regression corpus
 
@@ -106,31 +34,3 @@ few exist on purpose, to track known confusions (e.g. formal/synthesized IVR
 scripts reading as MACHINE) rather than hide them.
 Licensing and attribution for every third-party clip is in
 `test/fixtures/regression/ATTRIBUTION.md`.
-
-## Automated verification
-
-`test/agiAudiosocket.integration.test.ts` starts the real AGI and AudioSocket
-listeners in-process, plays both sides of Asterisk's role over raw TCP (the
-FastAGI header handshake with `agi_arg_1` set, `EXEC AudioSocket`, streaming
-real fixture PCM frame-by-frame, then reading back whatever `SET VARIABLE`
-commands the server issues), and asserts the values that arrive over that
-wire match calling the classifier directly on the same audio — for both
-compact (default) and full mode, plus a case confirming an unrecognized mode
-argument falls back to compact. This is the primary proof that the
-AGI+AudioSocket mechanism and the mode flag work end-to-end; run it with:
-
-```sh
-npm run integration
-```
-
-## Status after the rebuild
-
-Asterisk is retired (cleanbreak CB-B6), so the AGI and AudioSocket front end has no caller and its
-Asterisk smoke test is gone. The classifier stays: it moves behind a voice-worker listener in
-`add-media-node` task 4.3.
-
-## Development
-
-```sh
-npm run start:dev -w @fonoster/amd
-```

package/dist/index.d.ts

@@ -16,8 +16,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from "./agi/server";
-export * from "./audiosocket/server";
 export * from "./amd/AmdModel";
-export * from "./amd/buildAmdVariables";
-export * from "./probe/runProbe";

package/dist/index.js

@@ -32,8 +32,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-__exportStar(require("./agi/server"), exports);
-__exportStar(require("./audiosocket/server"), exports);
 __exportStar(require("./amd/AmdModel"), exports);
-__exportStar(require("./amd/buildAmdVariables"), exports);
-__exportStar(require("./probe/runProbe"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fonoster/amd",
-  "version": "0.30.0",
-  "description": "Standalone answering-machine-detection sidecar for the Fonoster platform",
+  "version": "0.31.0",
+  "description": "Answering-machine-detection model (ONNX) used by AppBridge",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/fonoster#readme",
   "license": "MIT",
@@ -14,20 +14,12 @@
   "scripts": {
     "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
     "build": "tsc -b tsconfig.json",
-    "clean": "rimraf ./dist node_modules tsconfig.tsbuildinfo",
-    "generate:readme": "node ../../.scripts/gen-readme.cjs",
-    "start:dev": "nodemon --exec tsx --watch src src/server.ts"
+    "generate:readme": "fonoster-readme"
   },
   "dependencies": {
-    "@fonoster/common": "^0.30.0",
-    "@fonoster/logger": "^0.30.0",
-    "@fonoster/streams": "^0.30.0",
-    "@fonoster/types": "^0.30.0",
-    "onnxruntime-node": "1.21.1",
-    "uuid": "^11.0.3"
-  },
-  "devDependencies": {
-    "@types/uuid": "^10.0.0"
+    "@fonoster/common": "^0.31.0",
+    "@fonoster/types": "^0.31.0",
+    "onnxruntime-node": "1.30.0"
   },
   "files": [
     "dist",
@@ -43,5 +35,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/fonoster/issues"
   },
-  "gitHead": "b59b06a3ef325abe3f188c0fb87cc22d50ed5471"
+  "gitHead": "f0a5102dddeea0f70f659234108805bc10690f2e"
 }

package/dist/agi/AgiChannel.d.ts

@@ -1,77 +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 { EventEmitter } from "events";
-import * as net from "net";
-/**
- * Thrown when the channel hangs up (or the socket closes) while a command is
- * in flight, or when a command is attempted on an already-hung-up channel.
- */
-declare class AgiHangupError extends Error {
-    constructor(message?: string);
-}
-/**
- * One FastAGI session. Minimal, hand-rolled client for the handful of
- * commands this module needs (EXEC, SET VARIABLE) — see AgiServer.ts for why
- * this exists instead of a dependency: the only maintained npm package for
- * this protocol (`asteriskagi`) shipped a broken `require()` in its latest
- * release at the time this was written.
- *
- * The AGI protocol is a simple line-based request/response: write one
- * command line, read back one `200 result=...` line. Asterisk may also send
- * an unsolicited `HANGUP` line at any time if the channel hangs up mid-command.
- */
-declare class AgiChannel extends EventEmitter {
-    readonly channel: string;
-    readonly uniqueid: string;
-    readonly variables: Record<string, string>;
-    private socket;
-    private buffer;
-    private ended;
-    private pending?;
-    constructor(props: {
-        socket: net.Socket;
-        variables: Record<string, string>;
-    });
-    get hungup(): boolean;
-    /**
-     * Dialplan arguments passed after the AGI URI, e.g.
-     * `AGI(agi://amd:4573,${AMD_MODE})` arrives as `agi_arg_1`, read
-     * here as `args[0]`. Standard AGI behavior, same for FastAGI as for a
-     * local script.
-     */
-    get args(): string[];
-    private onData;
-    private resolvePending;
-    private end;
-    /** Sends one raw FastAGI command line and waits for its response. */
-    send(command: string): Promise<void>;
-    /** Runs a dialplan application via `EXEC`, e.g. `exec("AudioSocket", args)`. */
-    exec(application: string, args?: string): Promise<void>;
-    setVariable(name: string, value: string): Promise<void>;
-    /**
-     * Ends the AGI session cleanly once this side is done issuing commands.
-     * This — not a special "done" command — is how Asterisk's AGI() app knows
-     * to return control to the dialplan: it detects the AGI script closing the
-     * connection. Without this, a real channel would sit in AGI() forever.
-     * Distinct from `end()`'s hangup semantics: this is *us* finishing, not
-     * the far end going away, so it doesn't emit "hangup".
-     */
-    close(): void;
-}
-export { AgiChannel, AgiHangupError };

package/dist/agi/AgiChannel.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgiHangupError = exports.AgiChannel = 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 events_1 = require("events");
-/**
- * Thrown when the channel hangs up (or the socket closes) while a command is
- * in flight, or when a command is attempted on an already-hung-up channel.
- */
-class AgiHangupError extends Error {
-    constructor(message = "AGI channel hung up") {
-        super(message);
-        this.name = "AgiHangupError";
-    }
-}
-exports.AgiHangupError = AgiHangupError;
-/**
- * One FastAGI session. Minimal, hand-rolled client for the handful of
- * commands this module needs (EXEC, SET VARIABLE) — see AgiServer.ts for why
- * this exists instead of a dependency: the only maintained npm package for
- * this protocol (`asteriskagi`) shipped a broken `require()` in its latest
- * release at the time this was written.
- *
- * The AGI protocol is a simple line-based request/response: write one
- * command line, read back one `200 result=...` line. Asterisk may also send
- * an unsolicited `HANGUP` line at any time if the channel hangs up mid-command.
- */
-class AgiChannel extends events_1.EventEmitter {
-    constructor(props) {
-        var _a, _b;
-        super();
-        this.buffer = "";
-        this.ended = false;
-        this.onData = (data) => {
-            if (this.ended)
-                return;
-            this.buffer += data.toString();
-            let newline = this.buffer.indexOf("\n");
-            while (newline >= 0) {
-                const line = this.buffer.slice(0, newline).replace(/\r$/, "").trim();
-                this.buffer = this.buffer.slice(newline + 1);
-                if (line === "HANGUP") {
-                    this.end();
-                    return;
-                }
-                if (line)
-                    this.resolvePending(line);
-                newline = this.buffer.indexOf("\n");
-            }
-        };
-        this.socket = props.socket;
-        this.variables = props.variables;
-        this.channel = (_a = props.variables.channel) !== null && _a !== void 0 ? _a : "";
-        this.uniqueid = (_b = props.variables.uniqueid) !== null && _b !== void 0 ? _b : "";
-        this.socket.on("data", this.onData);
-        this.socket.once("end", () => this.end());
-        this.socket.once("close", () => this.end());
-        this.socket.once("error", (err) => this.end(err));
-    }
-    get hungup() {
-        return this.ended;
-    }
-    /**
-     * Dialplan arguments passed after the AGI URI, e.g.
-     * `AGI(agi://amd:4573,${AMD_MODE})` arrives as `agi_arg_1`, read
-     * here as `args[0]`. Standard AGI behavior, same for FastAGI as for a
-     * local script.
-     */
-    get args() {
-        const result = [];
-        for (let i = 1; this.variables[`arg_${i}`] !== undefined; i++) {
-            result.push(this.variables[`arg_${i}`]);
-        }
-        return result;
-    }
-    resolvePending(line) {
-        const pending = this.pending;
-        if (!pending)
-            return;
-        this.pending = undefined;
-        // "200 result=1 ..." on success; "5xx ..." or a negative result on
-        // failure — either way this only needs to settle the promise, not parse
-        // the (unused) payload.
-        const match = line.match(/^\d+\s+result=(-?\d+)/);
-        const result = match ? Number(match[1]) : NaN;
-        if (line.startsWith("2") && !(Number.isFinite(result) && result < 0)) {
-            pending.resolve();
-        }
-        else {
-            pending.reject(new Error(`AGI command failed: ${line}`));
-        }
-    }
-    end(cause) {
-        if (this.ended)
-            return;
-        this.ended = true;
-        this.socket.off("data", this.onData);
-        const pending = this.pending;
-        this.pending = undefined;
-        pending === null || pending === void 0 ? void 0 : pending.reject(new AgiHangupError());
-        if (!this.socket.destroyed)
-            this.socket.end();
-        this.emit("hangup", cause);
-    }
-    /** Sends one raw FastAGI command line and waits for its response. */
-    send(command) {
-        if (this.ended)
-            return Promise.reject(new AgiHangupError());
-        if (this.pending) {
-            return Promise.reject(new Error("An AGI command is already in progress"));
-        }
-        return new Promise((resolve, reject) => {
-            this.pending = { resolve, reject };
-            if (!this.socket.writable || this.socket.destroyed) {
-                this.end();
-                return;
-            }
-            this.socket.write(command + "\n", "utf8", (err) => {
-                if (err)
-                    this.end(err);
-            });
-        });
-    }
-    /** Runs a dialplan application via `EXEC`, e.g. `exec("AudioSocket", args)`. */
-    exec(application, args) {
-        return this.send(`EXEC ${application} ${args !== null && args !== void 0 ? args : ""}`);
-    }
-    setVariable(name, value) {
-        return this.send(`SET VARIABLE ${name} "${value}"`);
-    }
-    /**
-     * Ends the AGI session cleanly once this side is done issuing commands.
-     * This — not a special "done" command — is how Asterisk's AGI() app knows
-     * to return control to the dialplan: it detects the AGI script closing the
-     * connection. Without this, a real channel would sit in AGI() forever.
-     * Distinct from `end()`'s hangup semantics: this is *us* finishing, not
-     * the far end going away, so it doesn't emit "hangup".
-     */
-    close() {
-        if (this.ended)
-            return;
-        this.ended = true;
-        this.socket.off("data", this.onData);
-        // A command can still be in flight (e.g. the caller gave up on it via an
-        // external race/timeout rather than waiting for a response) — settle it
-        // so that awaiter doesn't hang forever, same as end()'s hangup path.
-        const pending = this.pending;
-        this.pending = undefined;
-        pending === null || pending === void 0 ? void 0 : pending.reject(new AgiHangupError("AGI session closed locally"));
-        if (!this.socket.destroyed)
-            this.socket.end();
-    }
-}
-exports.AgiChannel = AgiChannel;

package/dist/agi/AgiServer.d.ts

@@ -1,34 +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 { EventEmitter } from "events";
-/**
- * Minimal FastAGI (`agi://host:port`) server: Asterisk connects, sends a
- * block of `agi_*` header lines terminated by a blank line, then this emits
- * "call" with an AgiChannel the caller can issue EXEC/SET VARIABLE commands
- * on. See AgiChannel.ts for why this is hand-rolled rather than a dependency.
- */
-declare class AgiServer extends EventEmitter {
-    private server;
-    constructor(props: {
-        port: number;
-    });
-    private handleConnection;
-    close(): void;
-}
-export { AgiServer };

package/dist/agi/AgiServer.js

@@ -1,109 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgiServer = 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 events_1 = require("events");
-const net = __importStar(require("net"));
-const AgiChannel_1 = require("./AgiChannel");
-/**
- * Minimal FastAGI (`agi://host:port`) server: Asterisk connects, sends a
- * block of `agi_*` header lines terminated by a blank line, then this emits
- * "call" with an AgiChannel the caller can issue EXEC/SET VARIABLE commands
- * on. See AgiChannel.ts for why this is hand-rolled rather than a dependency.
- */
-class AgiServer extends events_1.EventEmitter {
-    constructor(props) {
-        super();
-        this.server = net.createServer(this.handleConnection.bind(this));
-        this.server.on("error", (err) => this.emit("error", err));
-        this.server.listen(props.port, () => this.emit("ready", props.port));
-    }
-    handleConnection(socket) {
-        let buffer = "";
-        const onData = (data) => {
-            buffer += data.toString();
-            const delimiter = buffer.match(/\r?\n\r?\n/);
-            if (!delimiter || delimiter.index === undefined)
-                return;
-            socket.off("data", onData);
-            socket.off("error", onError);
-            const header = buffer.slice(0, delimiter.index);
-            const remainder = buffer.slice(delimiter.index + delimiter[0].length);
-            const variables = {};
-            header.split(/\r?\n/).forEach((line) => {
-                if (!line.startsWith("agi_"))
-                    return;
-                const separator = line.indexOf(":");
-                if (separator < 0)
-                    return;
-                variables[line.slice(4, separator).trim()] = line
-                    .slice(separator + 1)
-                    .trim();
-            });
-            const channel = new AgiChannel_1.AgiChannel({ socket, variables });
-            this.emit("call", channel);
-            if (remainder)
-                socket.unshift(Buffer.from(remainder));
-        };
-        const onError = (err) => {
-            if (this.listenerCount("error"))
-                this.emit("error", err);
-        };
-        socket.once("error", onError);
-        socket.on("data", onData);
-    }
-    close() {
-        this.server.close();
-    }
-}
-exports.AgiServer = AgiServer;

package/dist/agi/server.d.ts

@@ -1,16 +0,0 @@
-import { AgiServer } from "./AgiServer";
-/**
- * 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.
- */
-declare function startAgiServer(): AgiServer;
-export { startAgiServer };