@intelliweave/embedded 1.6.45

package/dist/node/node.d.ts

@@ -0,0 +1,1109 @@
+import * as onnxruntime_web from 'onnxruntime-web';
+import { InferenceSession, Tensor } from 'onnxruntime-web';
+
+/**
+ * This is a utility class for dealing with the ONNX runtime and model loading.
+ */
+declare class ONNXModel {
+    /** ONNX runtime loader. Example: `ONNXModel.lib = () => import('onnxruntime-web')` */
+    static lib?: () => Promise<typeof onnxruntime_web>;
+    /** Loaded ONNX runtime */
+    static onnx?: typeof onnxruntime_web;
+    /** True if this device supports the ONNX runtime */
+    static isSupported(): boolean;
+    /** The loaded model */
+    session: InferenceSession;
+    /** Tensors used for state, ie they are passed from the output to the next input */
+    stateTensors: {
+        [key: string]: {
+            tensor: Tensor;
+            outputName: string;
+        };
+    };
+    /** Constant tensors that will always be passed as-is to the input */
+    constantTensors: ONNXTensors;
+    /** Load a model */
+    static load(modelURL: string): Promise<ONNXModel>;
+    /** Constructor */
+    constructor(session: InferenceSession);
+    /** Create a new tensor zeroed from the specified definition */
+    makeTensor(type: BufferType, dims: number[], fillWith?: number): onnxruntime_web.TypedTensor<"float32"> | onnxruntime_web.TypedTensor<"int8"> | onnxruntime_web.TypedTensor<"int16"> | onnxruntime_web.TypedTensor<"int32"> | onnxruntime_web.TypedTensor<"int64"> | onnxruntime_web.TypedTensor<"uint8"> | onnxruntime_web.TypedTensor<"uint16"> | onnxruntime_web.TypedTensor<"uint32"> | onnxruntime_web.TypedTensor<"uint64">;
+    /** Register a static tensor, ie one that will be passed to the input on every call */
+    registerConstant(name: string, tensor: Tensor): Tensor;
+    /** Create and register a static tensor, ie one that will be passed to the input on every call */
+    makeConstant(name: string, type: BufferType, dims: number[], fillWith?: number): Tensor;
+    /** Register a state tensor, ie one that will be passed from the output to the input */
+    registerState(inputName: string, outputName: string, tensor: Tensor): Tensor;
+    /** Create and register a state tensor, ie one that will be passed from the output to the input */
+    makeState(inputName: string, outputName: string, type: BufferType, dims: number[], fillWith?: number): Tensor;
+    /** True if a previous run is still active */
+    private _runActive;
+    /** If true, will ignore a request to run if a previous run is still active. Otherwise, will throw an error */
+    ignoreIfBusy: boolean;
+    /** Run the model */
+    run(inputs?: ONNXTensors): Promise<void | InferenceSession.OnnxValueMapType>;
+    /** Reset state tensors to zero */
+    resetState(): void;
+}
+/** A collection of named tensors */
+type ONNXTensors = {
+    [key: string]: Tensor;
+};
+/** Buffer types */
+type BufferType = 'float32' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint8' | 'uint16' | 'uint32' | 'uint64';
+
+/** Convert an array of Float32Array audio buffers to a WAV file */
+declare function audioToWav(sampleRate: number, buffers: Float32Array[]): File;
+
+/** WebSocket that lets you send packets before connection is opened */
+declare class BufferedWebSocket extends WebSocket {
+    /** Pending data to send */
+    pendingData: any[];
+    /** Constructor */
+    constructor(url: string);
+    /** Send data */
+    send(data: any): void;
+    /** Called when the connection opens */
+    private _onOpen;
+}
+
+/** Supported classes */
+type SupportedArrayBuffers = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array;
+/**
+ * This class accepts an input of a variable amount of data elements, and outputs a fixed amount of data elements.
+ */
+declare class FixedBufferStream<ArrayType extends SupportedArrayBuffers> {
+    /** The class to use when creating buffers, ie Int16Array, Float32Array, etc */
+    ArrayClass?: Function;
+    /** Number of elements in the output buffers */
+    outputBufferSize: number;
+    /** Partial buffers */
+    partialBuffers: ArrayType[];
+    /** The amount of bytes already consumed from the first buffer in the `buffers` array */
+    partialBufferOffset: number;
+    /** Get number of queued elements */
+    get queuedSize(): number;
+    /**
+     * Constructor
+     *
+     * @param outputBufferSize - Number of elements in the output buffers
+     */
+    constructor(ArrayClass: Function, outputBufferSize: number);
+    /** Feed data in */
+    feed(data: ArrayType): void;
+    /** True if there's enough data to return a buffer from drain() */
+    get canDrain(): boolean;
+    /** Pull the next chunk of fixed data, or else returns null if no more data */
+    drain(): ArrayType | null;
+    /** Pad the buffer with zeroes to fill the remaining chunk */
+    pad(): void;
+}
+
+/**
+ * @author  Created by felix on 18-7-2.
+ * @email   307253927@qq.com
+ * @source  https://github.com/felix307253927/resampler/blob/master/Resampler.js
+ */
+
+class Resampler {
+  constructor(fromSampleRate, toSampleRate, channels, inputBufferSize) {
+    
+    if (!fromSampleRate || !toSampleRate || !channels) {
+      throw(new Error("Invalid settings specified for the resampler."));
+    }
+    this.resampler       = null;
+    this.fromSampleRate  = fromSampleRate;
+    this.toSampleRate    = toSampleRate;
+    this.channels        = channels || 0;
+    this.inputBufferSize = inputBufferSize;
+    this.initialize();
+  }
+  
+  initialize() {
+    if (this.fromSampleRate == this.toSampleRate) {
+      
+      // Setup resampler bypass - Resampler just returns what was passed through
+      this.resampler   = (buffer) => {
+        return buffer
+      };
+      this.ratioWeight = 1;
+      
+    } else {
+      
+      if (this.fromSampleRate < this.toSampleRate) {
+        
+        // Use generic linear interpolation if upsampling,
+        // as linear interpolation produces a gradient that we want
+        // and works fine with two input sample points per output in this case.
+        this.linearInterpolation();
+        this.lastWeight = 1;
+        
+      } else {
+        
+        // Custom resampler I wrote that doesn't skip samples
+        // like standard linear interpolation in high downsampling.
+        // This is more accurate than linear interpolation on downsampling.
+        this.multiTap();
+        this.tailExists = false;
+        this.lastWeight = 0;
+      }
+      
+      // Initialize the internal buffer:
+      this.initializeBuffers();
+      this.ratioWeight = this.fromSampleRate / this.toSampleRate;
+    }
+  }
+  
+  bufferSlice(sliceAmount) {
+    
+    //Typed array and normal array buffer section referencing:
+    try {
+      return this.outputBuffer.subarray(0, sliceAmount);
+    }
+    catch (error) {
+      try {
+        //Regular array pass:
+        this.outputBuffer.length = sliceAmount;
+        return this.outputBuffer;
+      }
+      catch (error) {
+        //Nightly Firefox 4 used to have the subarray function named as slice:
+        return this.outputBuffer.slice(0, sliceAmount);
+      }
+    }
+  }
+  
+  initializeBuffers() {
+    this.outputBufferSize = (Math.ceil(this.inputBufferSize * this.toSampleRate / this.fromSampleRate / this.channels * 1.000000476837158203125) + this.channels) + this.channels;
+    try {
+      this.outputBuffer = new Float32Array(this.outputBufferSize);
+      this.lastOutput   = new Float32Array(this.channels);
+    }
+    catch (error) {
+      this.outputBuffer = [];
+      this.lastOutput   = [];
+    }
+  }
+  
+  linearInterpolation() {
+    this.resampler = (buffer) => {
+      let bufferLength = buffer.length,
+          channels     = this.channels,
+          outLength,
+          ratioWeight,
+          weight,
+          firstWeight,
+          secondWeight,
+          sourceOffset,
+          outputOffset,
+          outputBuffer,
+          channel;
+      
+      if ((bufferLength % channels) !== 0) {
+        throw(new Error("Buffer was of incorrect sample length."));
+      }
+      if (bufferLength <= 0) {
+        return [];
+      }
+      
+      outLength    = this.outputBufferSize;
+      ratioWeight  = this.ratioWeight;
+      weight       = this.lastWeight;
+      firstWeight  = 0;
+      secondWeight = 0;
+      sourceOffset = 0;
+      outputOffset = 0;
+      outputBuffer = this.outputBuffer;
+      
+      for (; weight < 1; weight += ratioWeight) {
+        secondWeight    = weight % 1;
+        firstWeight     = 1 - secondWeight;
+        this.lastWeight = weight % 1;
+        for (channel = 0; channel < this.channels; ++channel) {
+          outputBuffer[outputOffset++] = (this.lastOutput[channel] * firstWeight) + (buffer[channel] * secondWeight);
+        }
+      }
+      weight -= 1;
+      for (bufferLength -= channels, sourceOffset = Math.floor(weight) * channels; outputOffset < outLength && sourceOffset < bufferLength;) {
+        secondWeight = weight % 1;
+        firstWeight  = 1 - secondWeight;
+        for (channel = 0; channel < this.channels; ++channel) {
+          outputBuffer[outputOffset++] = (buffer[sourceOffset + ((channel > 0) ? (channel) : 0)] * firstWeight) + (buffer[sourceOffset+(channels + channel)] * secondWeight);
+        }
+        weight += ratioWeight;
+        sourceOffset = Math.floor(weight) * channels;
+      }
+      for (channel = 0; channel < channels; ++channel) {
+        this.lastOutput[channel] = buffer[sourceOffset++];
+      }
+      return this.bufferSlice(outputOffset);
+    };
+  }
+  
+  multiTap() {
+    this.resampler = (buffer) => {
+      let bufferLength = buffer.length,
+          outLength,
+          output_variable_list,
+          channels     = this.channels,
+          ratioWeight,
+          weight,
+          channel,
+          actualPosition,
+          amountToNext,
+          alreadyProcessedTail,
+          outputBuffer,
+          outputOffset,
+          currentPosition;
+      
+      if ((bufferLength % channels) !== 0) {
+        throw(new Error("Buffer was of incorrect sample length."));
+      }
+      if (bufferLength <= 0) {
+        return [];
+      }
+      
+      outLength            = this.outputBufferSize;
+      output_variable_list = [];
+      ratioWeight          = this.ratioWeight;
+      weight               = 0;
+      actualPosition       = 0;
+      amountToNext         = 0;
+      alreadyProcessedTail = !this.tailExists;
+      this.tailExists      = false;
+      outputBuffer         = this.outputBuffer;
+      outputOffset         = 0;
+      currentPosition      = 0;
+      
+      for (channel = 0; channel < channels; ++channel) {
+        output_variable_list[channel] = 0;
+      }
+      
+      do {
+        if (alreadyProcessedTail) {
+          weight = ratioWeight;
+          for (channel = 0; channel < channels; ++channel) {
+            output_variable_list[channel] = 0;
+          }
+        } else {
+          weight = this.lastWeight;
+          for (channel = 0; channel < channels; ++channel) {
+            output_variable_list[channel] = this.lastOutput[channel];
+          }
+          alreadyProcessedTail = true;
+        }
+        while (weight > 0 && actualPosition < bufferLength) {
+          amountToNext = 1 + actualPosition - currentPosition;
+          if (weight >= amountToNext) {
+            for (channel = 0; channel < channels; ++channel) {
+              output_variable_list[channel] += buffer[actualPosition++] * amountToNext;
+            }
+            currentPosition = actualPosition;
+            weight -= amountToNext;
+          } else {
+            for (channel = 0; channel < channels; ++channel) {
+              output_variable_list[channel] += buffer[actualPosition + ((channel > 0) ? channel : 0)] * weight;
+            }
+            currentPosition += weight;
+            weight = 0;
+            break;
+          }
+        }
+        
+        if (weight === 0) {
+          for (channel = 0; channel < channels; ++channel) {
+            outputBuffer[outputOffset++] = output_variable_list[channel] / ratioWeight;
+          }
+        } else {
+          this.lastWeight = weight;
+          for (channel = 0; channel < channels; ++channel) {
+            this.lastOutput[channel] = output_variable_list[channel];
+          }
+          this.tailExists = true;
+          break;
+        }
+      } while (actualPosition < bufferLength && outputOffset < outLength);
+      return this.bufferSlice(outputOffset);
+    };
+  }
+  
+  resample(buffer) {
+    if (this.fromSampleRate == this.toSampleRate) {
+      this.ratioWeight = 1;
+    } else {
+      if (this.fromSampleRate < this.toSampleRate) {
+        this.lastWeight = 1;
+      } else {
+        this.tailExists = false;
+        this.lastWeight = 0;
+      }
+      this.initializeBuffers();
+      this.ratioWeight = this.fromSampleRate / this.toSampleRate;
+    }
+    return this.resampler(buffer)
+  }
+}
+
+/**
+ * 将无符号Float32Array数组转化成有符号的Int16Array数组
+ * @param {Float32Array} input unsinged Float32Array
+ * @return {Int16Array} singed int16
+ */
+function floatTo16BitPCM(input) {
+  let i      = input.length;
+  let output = new Int16Array(i);
+  while (i--) {
+    let s     = Math.max(-1, Math.min(1, input[i]));
+    output[i] = (s < 0 ? s * 0x8000 : s * 0x7FFF);
+  }
+  return output;
+}
+
+function floatTo64BitPCM(input) {
+  let i      = input.length;
+  let output = new BigInt64Array(i);
+  while (i--) {
+    let s     = Math.max(-1, Math.min(1, input[i]));
+    output[i] = BigInt(Math.floor((s < 0 ? s * 0x8000 : s * 0x7FFF))) * 0x100000000000n;//(s < 0 ? s : s * 0x7FFFFFFFFFFFFFFFn);
+  }
+  return output;
+}
+
+/**
+ * 将有符号的Int16Array数组转化成无符号Float32Array数组
+ * @param {Int16Array} input singed int16
+ * @return {Float32Array}  // unsinged float32
+ */
+function int16ToFloat32BitPCM(input) {
+  let i      = input.length;
+  let output = new Float32Array(i);
+  while (i--) {
+    let int   = input[i];
+    output[i] = (int >= 0x8000) ? -(0x10000 - int) / 0x8000 : int / 0x7FFF;
+  }
+  return output;
+}
+
+/** Utility to trim whitespace from blocks of text */
+declare function trimWhitespaceInText(text: string): string;
+/** Get the global object */
+declare function intelliweaveGlobalThis(): any;
+/** Get the global IntelliWeave configuration object that has been created for this document, or create it if necessary. */
+declare function intelliweaveConfig(): any;
+/** An async generator which yields events from an SSE fetch request body (a readable stream) */
+declare function sseEvents(stream: ReadableStream<Uint8Array>): AsyncGenerator<any, void, unknown>;
+/** Get or create a user ID for this device. */
+declare function getDefaultUserID(): string;
+
+/** ChatGPT config options */
+interface ChatGPTConfig {
+    /** API key */
+    apiKey: string;
+    /** Provider ID */
+    providerID?: string;
+    /** Endpoint URL if using a custom URL */
+    endpoint: string;
+    /** LLM model to use */
+    model: string;
+    /** System message to describe to the AI how to behave. */
+    systemMessage: string;
+    /** User ID used to uniquely identify users in ChatGPT's API */
+    userID: string;
+    /** If true, streams the text responses from the API */
+    stream: boolean;
+    /** Amount of estimated tokens to keep when trimming */
+    maxTokens: number;
+    /** Callback before the AI sends info to the LLM */
+    onBeforeMessageProcessing?: () => void;
+    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
+    onAIMessage?: (text: string, isChunk: boolean) => void;
+    /** Callback when the AI starts performing an action */
+    onAIToolStart?: (toolName: string, input: any) => void;
+}
+/** ChatGPT tool config */
+interface ChatGPTToolConfig {
+    /** Name of the tool */
+    name: string;
+    /** Description of the tool */
+    description: string;
+    /** Parameters for the tool */
+    params: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    /** Callback function to process the tool */
+    callback: (params: any) => any;
+    /** If true, this tool call will be removed from the message history after it is executed. */
+    removeFromMessageHistory?: boolean;
+    /** Misc app context */
+    [key: string]: any;
+}
+/**
+ * API for interacting with ChatGPT APIs.
+ */
+declare class ChatGPT {
+    /** ID */
+    id: string;
+    /** Metadata */
+    metadata: any;
+    /** Config */
+    config: ChatGPTConfig;
+    /** List of messages in the chat history */
+    messages: any[];
+    /** List of available tools */
+    tools: ChatGPTToolConfig[];
+    /** The maximum tool calls in sequence the AI can make before an error is thrown. */
+    maxToolCallsPerMessage: number;
+    private _hasRemovedToolCallHistorySinceLastMessage;
+    /** Statistics */
+    stats: {
+        /** Total tokens used this session */
+        tokensUsed: number;
+    };
+    /** Constructor */
+    constructor(config: ChatGPTConfig);
+    /** Send a message, and get the response */
+    sendMessage(message: string): Promise<string>;
+    /** @private Process messages in the chat history */
+    processMessages(): Promise<void>;
+    /** Trim message list */
+    trimMessages(): Promise<void>;
+    /** @private Send message list to the API and store the response */
+    sendToAPI(generatePayloadOnly?: boolean): Promise<any>;
+    /** Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
+    processIncomingMessage(message: string): void;
+    /** Register a tool. */
+    registerTool(tool: ChatGPTToolConfig): void;
+    /** @private Process a tool call request from the AI */
+    processToolCall(toolCall: any): Promise<void>;
+    /** Reset the conversation */
+    resetConversation(): void;
+}
+
+/**
+ * Speech output
+ *
+ * - event `speechstart` - When the speech starts
+ * - event `speechend` - When the speech ends
+ */
+declare class WebWeaverSpeechOutput extends EventTarget {
+    /** Reference to the AI */
+    private ai?;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Called when the AI speaks */
+    onTextOutputFromAI(e: CustomEvent): void;
+    /** Current player vars */
+    private currentPlayerVolume?;
+    private currentPlayer?;
+    /** Speak the text */
+    speak(text: string): Promise<void>;
+    private _speakWithLock;
+    /** True if currently playing audio */
+    get isSpeaking(): boolean;
+    /** Interrupt the previously playing audio */
+    interrupt(): Promise<void>;
+    /** Called when the speech output ends */
+    onSpeechEnd(): void;
+}
+
+/**
+ * An AudioWorklet module that records data from input and sends it to the host.
+ *
+ * - event `data` - Fired when data is available to be read.
+ */
+declare class PCMReceiverNode extends AudioWorkletNode {
+    /** @type {'int16' | 'float32'} The output data format */
+    format: string;
+    /**
+     * Creates a new PCMRecorderNode ready to receive PCM data.
+     *
+     * @param context - The audio context to use.
+     * @param sampleRate - The sample rate of the output data stream.
+     * @param format - The format of the output data stream.
+     * @param bufferSize - The size of the output buffer in elements (Int16Array or Float32Array items, depending on `format`).
+     */
+    constructor(context: AudioContext, sampleRate: number, format: 'int16' | 'int64' | 'float32', bufferSize: number);
+    /** @private Called when a message is received from the worklet */
+    onWorkletMessage(e: MessageEvent): void;
+    /** Called when data is received */
+    onData(buffer: Float32Array | Int16Array | BigInt64Array): void;
+}
+
+/**
+ * An AudioNode which sends events for when speech is detected
+ *
+ * - event `speechstart` - Fired when speech is detected
+ * - event `speechend` - Fired when speech ends
+ */
+declare class VoiceDetectionNode extends PCMReceiverNode {
+    /** True if voice is currently being detected */
+    isVoiceActive: boolean;
+    /** True if voice is active but may be ending soon */
+    get isVoicePossiblyEnding(): boolean;
+    /** Last date that voice was detected */
+    lastVoiceActiveDate: number;
+    /** Amount of time to wait after voice detection to detect that it has ended */
+    voiceEndTimeout: number;
+    /** Detection sensitivity, if the detection model outputs a number bigger than this it will be considered voice */
+    sensitivity: number;
+    /** Sensitivity threshold to end speaking */
+    sentivityEnd: number;
+    /** VAD model */
+    static vadModelURL: string;
+    /** Loaded VAD model */
+    private vad?;
+    /** Sample rate */
+    get sampleRate(): 8000 | 16000;
+    /** Number of samples */
+    get numberOfSamples(): number;
+    /** Number of sample chunks */
+    get numberOfSampleChunks(): number;
+    /** Output buffer size */
+    get outputBufferSize(): number;
+    /** True if the VAD model has been loaded */
+    get isModelLoaded(): boolean;
+    /** The time when to next reset the VAD model */
+    nextVadReset: number;
+    /** The current probability of active voice */
+    currentProbability: number;
+    /** Constructor */
+    constructor(audioContext: AudioContext);
+    /** Start loading */
+    loadModel(): Promise<void>;
+    private _lastVoiceActive;
+    /** Called when data is received */
+    onData(buffer: Float32Array): Promise<void>;
+    /** Called when speech is detected */
+    onSpeechStart(): void;
+    /** Called when speech ends */
+    onSpeechEnd(): void;
+}
+
+/**
+ * An AudioNode which isolates speech and outputs the audio data. Since we are reusing the VAD model node,
+ * output data is in 8000Hz Float32 format.
+ *
+ * - event `voicedata` - Fired when a chunk of voice is detected. `data` contains the recorded chunk of voice in a Float32Array.
+ * - event `voicedataend` - Fired when this chunk of voice ends. `data` contains an array of Float32Array containing the entirety of the recorded voice.
+ */
+declare class VoiceChunkOutputNode extends VoiceDetectionNode {
+    /** Stored buffers */
+    buffers: Float32Array[];
+    /** Recorded audio chunks with voice in it */
+    recordedBuffers: Float32Array[];
+    /** Last active state */
+    _voiceRecording: boolean;
+    /** Amount of audio data in the buffer, in seconds */
+    get bufferDuration(): number;
+    /** Amount of data to keep from before the user started speaking */
+    backBufferDurationSeconds: number;
+    /** Called when data is received */
+    onData(buffer: Float32Array): Promise<void>;
+    /** Called when a chunk of voice is recorded */
+    onVoiceChunk(buffer: Float32Array): void;
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): void;
+}
+
+/**
+ * This AudioNode uses OpenAI's Whisper model to transcribe spoken speech to text.
+ *
+ * - event `transcription` - Fired when a transcription is ready. `text` contains the transcribed text.
+ */
+declare class OpenAITranscriptionNode extends VoiceChunkOutputNode {
+    /** OpenAI API key */
+    apiKey: string;
+    /** Pending buffers */
+    private pendingBuffers;
+    /** Last request */
+    private lastRequestAbortController?;
+    /** True if currently transcribing */
+    isTranscribing: boolean;
+    /** Constructor */
+    constructor(audioContext: AudioContext, apiKey: string);
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): Promise<void>;
+    /** Called when a transcription is ready */
+    onVoiceTranscription(text: string): void;
+}
+
+/**
+ * This AudioNode uses IntelliWeave's servers to transcribe spoken speech to text.
+ *
+ * - event `transcription` - Fired when a transcription is ready. `text` contains the transcribed text.
+ */
+declare class IntelliWeaveTranscriptionNode extends VoiceChunkOutputNode {
+    /** Debug: Export each recording as a wav file for download */
+    static debugExportWav: boolean;
+    /** Server address for transcription */
+    apiAddress: string;
+    /** OpenAI API key */
+    apiKey: string;
+    /** WebSocket connection */
+    private ws?;
+    /** True if currently transcribing */
+    isTranscribing: boolean;
+    /** WebSocket shutdown timer */
+    private shutdownTimer?;
+    /** Constructor */
+    constructor(audioContext: AudioContext, apiKey: string);
+    /** Called when a voice chunk is received */
+    onVoiceChunk(buffer: Float32Array): Promise<void>;
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): Promise<void>;
+    /** Called when a transcription is ready */
+    onVoiceTranscription(text: string): void;
+    /** Called when the WebSocket is closed */
+    onSocketClose(): void;
+}
+
+/**
+ * Handles speech recognition from the microphone
+ *
+ * - event `speechstart` - We have detected the user started speaking
+ * - event `speechend` - We have detected the user stopped speaking
+ * - event `speech` - Speech recognition result
+ * - event `start` - Speech recognition started
+ * - event `end` - Speech recognition ended
+ */
+declare class WebWeaverSpeechRecognition extends EventTarget {
+    /** Reference to the AI */
+    ai?: IntelliWeave;
+    /** True if recognition is running */
+    isRunning: boolean;
+    /** The audio analyser node */
+    analyserNode?: AnalyserNode;
+    /** The audio analyser buffer */
+    analyserBuffer?: Float32Array;
+    /** The microphone stream */
+    micStream?: MediaStream;
+    /** Returns true if speech recognition is supported by this persona and browser */
+    get isSupported(): boolean;
+    /** Currently active voice detection node */
+    voiceDetection?: IntelliWeaveTranscriptionNode | OpenAITranscriptionNode;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    private _skipEvents;
+    /** Start recognition */
+    start(): Promise<void>;
+    /** Stop recognition */
+    stop(): void;
+    /** @private Maximum volume heard this session */
+    maxVolumeHeard: number;
+    /** Get current (realtime) microphone volume level, from 0 to 1 */
+    get volumeLevel(): number;
+    /** True if currently detecting words being spoken */
+    get wordsCurrentlyBeingSpoken(): boolean;
+    /** True if currently transcribing voice to text */
+    get isTranscribing(): boolean;
+    /** Called when speech has been recorded */
+    onTranscription(e: CustomEvent): void;
+    /** Called to reset the speech recognizer */
+    reset(): Promise<void>;
+}
+
+/** Handles creating and managing the AudioContext */
+declare class AudioSystem {
+    /** Reference to the AI */
+    private ai?;
+    /** The speech recognition module. */
+    speechRecognition: WebWeaverSpeechRecognition;
+    /** The speech output module. */
+    speechOutput: WebWeaverSpeechOutput;
+    /** The audio context */
+    context?: AudioContext;
+    /** List of active named locks */
+    locks: string[];
+    /** Returns true if speech recognition and output is supported by this persona and browser */
+    static get isSupported(): boolean;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Create a named lock to enable the audio system */
+    beginAccess(namedLock: string): Promise<void>;
+    /** Stop accessing the audio system */
+    endAccess(namedLock: string): void;
+}
+
+/**
+ * This class allows you to use the AI as a logic engine, data extractor, etc.
+ */
+declare class AILogic {
+    /** Reference to the AI */
+    private ai?;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Ask the AI a yes/no question associated with the specified data. Data must be JSON-serializable, or a string of any kind of data. */
+    boolean(question: string, data: any): Promise<boolean>;
+    /**
+        Ask the AI to select a choice from a list of options. The AI will return the selected choice.
+        @param question The question to ask the AI.
+        @param data The data to provide to the AI. This can be a string or a JSON-serializable object.
+        @param options The list of options to choose from.
+     */
+    choose(question: string, data: any, options: string[]): Promise<string | undefined>;
+    /**
+     * Ask the AI to extract data from a text. The AI will return the extracted data. Possibly an array of multiple extractions.
+     *   Example: extract(myData, true, [
+     *   { name: "id", type: "string", description: "The user's ID number." },
+     *   { name: "firstName", type: "string", description: "The user's first name" },
+     *   ])
+     * @param question The question to ask the AI.
+     * @param data The data to provide to the AI. This can be a string or a JSON-serializable object.
+     * @param allowMultiple Whether to allow multiple extractions or not.
+     * @param extractions The list of extractions to perform. Each extraction is an object with the following properties:
+     * - name: The name of the extraction. This will be the key in the returned object.
+     * - type: The type of the extraction. This can be "string", "number", "boolean", "date", "email", "url", "phone", "address", "name", "organization", "person", "location", "time", "duration", "money", "percentage", "quantity", "custom".
+     * - description: A description of the extraction. This is optional.
+     */
+    extract(question: string, data: any, allowMultiple: boolean, extractions: {
+        name: string;
+        type: string;
+        description?: string;
+    }[]): Promise<any>;
+    /**
+     * Generate a Markdown document based on the input query from the user.
+     *
+     * @param query The query to generate the document from.
+     * @param callback The callback that will be called when streaming the response. Each call will contain the full text that has been generated so far.
+     */
+    generateMarkdown(query: string, callback: (txt: string) => void): Promise<string | null>;
+    /**
+     * Perform an instruction.
+     *
+     * @param instruction Describe the action to perform.
+     * @param query The user query to pass to the AI.
+     * @param callback The callback that will be called when streaming the response. Each call will contain the full text that has been generated so far.
+     * @returns The final response from the AI.
+     */
+    instruct(instruction: string, query: string, callback: (txt: string) => void): Promise<string | null>;
+}
+
+/** Persona config received from the hub */
+interface WebWeaverGPTConfig {
+    /** ID */
+    id: string;
+    /** ChatGPT config */
+    model: ChatGPTConfig;
+    /** If true, message history will be sent to the IntelliWeave hub for analysis */
+    analytics?: boolean;
+    /** Persona name */
+    name?: string;
+    /** Instructions to the AI */
+    instructions?: string;
+    /** Introduction message, used in the automatic UI */
+    introductionMessage?: string;
+    /** Voice information */
+    voice?: {
+        /** Provider ID */
+        providerID: string;
+        /** API key for the provider */
+        apiKey: string;
+        /** Voice ID within the provider */
+        voiceID: string;
+    };
+    /** Transcription API information */
+    transcription?: {
+        /** Provider ID */
+        providerID: string;
+        /** API key for the provider */
+        apiKey: string;
+        /** Optional URL for the transcription service */
+        url?: string;
+    };
+    /** Knowledge base sources */
+    knowledge?: KnowledgeBaseSource[];
+}
+/**
+ * IntelliWeave interface, loads a Persona from the hub and allows you to interact with it. This is the main entry point into the IntelliWeave
+ * SDK when not using the built-in UI.
+ *
+ * - event `load` - Fired when the AI is loaded with a new configuration.
+ * - event `error` - Fired when an error occurs during loading.
+ * - event `webweaver_loaded` - Fired when the AI is loaded with a new configuration. This is a global event that is fired on the window object.
+ * - event `webweaver_error` - Fired when an error occurs during loading. This is a global event that is fired on the window object.
+ * - event `input` - Fired when the user sends a message to the AI.
+ * - event `output` - Fired when the AI sends a message back to the user. If `event.detail.isChunk` is true, the message is incomplete and will be followed by more chunks.
+ * - event `toolstart` - Fired when the AI starts performing an action.
+ * - event `tool` - Fired when the AI finishes performing an action.
+ */
+declare class IntelliWeave extends EventTarget {
+    /** App version */
+    static version: string;
+    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
+    onAIMessage?: (text: string, isChunk: boolean) => void;
+    /** Callback when the AI starts performing an action */
+    onAIToolStart?: ChatGPTConfig['onAIToolStart'];
+    /** Current conversation ID */
+    conversationID: string;
+    /** Knowledge database interface */
+    knowledgeBase: KnowledgeBase;
+    /** Current knowledge base items */
+    private _lastKBentries;
+    /** Config loaded from the API */
+    config?: WebWeaverGPTConfig;
+    /** Available LLMs */
+    models: {
+        id: string;
+        config: ChatGPTConfig;
+        priority?: number;
+    }[];
+    /** Current LLM */
+    currentModel?: ChatGPT;
+    /** The audio system. Set this to a new instance of AudioSystem to enable audio support */
+    audio: AudioSystem | null;
+    /** Silero VAD model blob */
+    vadModel?: Blob;
+    /** True if the AI has loaded */
+    get loaded(): boolean;
+    /** If loading fails, this stores the last error during load() */
+    error?: Error;
+    /** IntelliWeave API key */
+    apiKey: string;
+    /** Tracker for the current voice interaction */
+    _voiceTracker?: (text: string) => void;
+    /** Logic engine */
+    logic: AILogic;
+    /** A unique ID to identify this user. Defaults to a value stored in localStorage, or random. */
+    userID: string;
+    /** Extra data that will be passed to external knowledge base actions. */
+    extra: any;
+    /** Set model and load data from an API key */
+    load(apiKey: string): Promise<WebWeaverGPTConfig>;
+    /** Set the current model */
+    setModel(id: string): void;
+    private _lastSystemMsg;
+    /** Get the system message prefix, before the KB entries are added */
+    getContextPrefix(): Promise<any>;
+    /** Get system message to send to the AI */
+    onBeforeMessageProcessing(): Promise<void>;
+    /** Called to update the current knowledge base items */
+    updateKnowledgeBase(items: KnowledgeBaseItem[]): void;
+    private _lastOutput?;
+    /** @private Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
+    processIncomingMessage(message: string, isChunk?: boolean): void;
+    /** True if currently processing a message */
+    isProcessing: boolean;
+    /** Send a message, and get the response */
+    sendMessage(message: string): Promise<string | null>;
+    /** @private Called when the AI wants to run a KB action */
+    toolRunKBAction(kb: KnowledgeBaseItem, input: any): Promise<any>;
+    /** Submit an analytics event asynchronously */
+    submitAnalyticsEvent(data: any): void;
+    /** Reset the conversation */
+    resetConversation(): void;
+    /** Insert a message as if the assistant has written it */
+    insertAssistantMessage(message: string): void;
+    /** Export conversation state to a JSON object */
+    exportState(): {
+        type: string;
+        conversationID: string;
+        messages: any[] | undefined;
+    };
+    /** Import conversation state from JSON */
+    importState(state: any): void;
+    /** Clone this instance */
+    clone(): IntelliWeave;
+}
+
+/**
+ * Register knowledge base sources and perform searches.
+ */
+declare class KnowledgeBase {
+    /** Reference to the AI */
+    ai?: IntelliWeave;
+    /** Knowledge base sources */
+    _sources: KnowledgeBaseSource[];
+    /** List of sources returned from the last window event */
+    _windowSources: KnowledgeBaseSource[];
+    /** List of last search results */
+    lastResults: KnowledgeBaseItem[];
+    /** Individual knowledge base entries added manually by the application */
+    manualEntries: KnowledgeBaseItem[];
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /**
+     * Register a new knowledge base source. You can pass either just a query function, or an ID and a query function.
+     *
+     * @param idOrQuery The ID of the source or a function that performs the query if no ID is provided
+     * @param query The function that performs the query. Can be undefined if the first param is a function.
+     */
+    registerSource(idOrQuery: string | KnowledgeBaseSource['query'], query?: KnowledgeBaseSource['query']): string;
+    /** Remove a knowledge base source */
+    removeSource(idOrQuery: string | KnowledgeBaseSource['query']): void;
+    /** Add a knowledge base item. */
+    addEntry(item: KnowledgeBaseItem): void;
+    /** Remove a knowledge base item. */
+    removeEntry(id: string): void;
+    /** Get all knowledge base sources */
+    get sources(): KnowledgeBaseSource[];
+    /** Search the knowledge base */
+    search(query: string): Promise<KnowledgeBaseItem[]>;
+    /** Get the KB entry with the specified ID. Requires the item to have been fetched in the last knowledge base query. */
+    getCachedEntry(id: string): KnowledgeBaseItem | undefined;
+    /** Create and register an external knowledge base source from a URL */
+    registerSourceFromURL(url: string, id?: string): void;
+    /** Clone this instance */
+    clone(): KnowledgeBase;
+}
+/** Knowledge base source */
+interface KnowledgeBaseSource {
+    /** Source ID */
+    id?: string;
+    /** Source name */
+    name?: string;
+    /** Optional description */
+    description?: string;
+    /** Optional icon URL */
+    icon?: string;
+    /** If true, this source will not be queried. */
+    disabled?: boolean;
+    /** Source query function. This function should return a list of knowledge base entries that optionally match the query. */
+    query?: (query: string) => (KnowledgeBaseItem[] | Promise<KnowledgeBaseItem[]>);
+    /** URL query for remote sources */
+    url?: string;
+}
+/** Knowledge base item */
+interface KnowledgeBaseItem {
+    /** Item ID */
+    id?: string;
+    /** Item type. */
+    type: 'info' | 'action' | 'tour' | 'input-event' | 'output-event';
+    /** Item name */
+    name: string;
+    /** Item tags. Helps with search optimization. */
+    tags?: string;
+    /** Item content. Can be a function to return a dynamic string. */
+    content: string | (() => string);
+    /** If true, this item will always be returned from all search results. */
+    isContext?: boolean;
+    /** If true, this item will not be visible to the AI. */
+    disabled?: boolean;
+    /** List of parameters for an action function. */
+    parameters?: ({
+        name: string;
+        type: 'string' | 'boolean' | 'number';
+        description: string;
+    })[];
+    /**
+     * Item action. The parameters are defined in `parameters`. The response is stringified and sent to the AI.
+     * You can return any JSON-serializable object. You can also return a string describing to the AI the action
+     * that was performed. If an error is thrown, the AI will respond appropriately to the user.
+     */
+    action?: (input: any, ai: IntelliWeave) => (any | Promise<any>);
+    /** If true, this item will be removed from the AI's message history after it gets called. This is a special case for LLMs that struggle with follow-up function calls and need to use the KB search functino first. */
+    removeFromMessageHistory?: boolean;
+}
+/** Format for incoming KB webook. Sent from IntelliWeave to your endpoint. */
+interface KnowledgeBaseWebhookRequest {
+    /** Type of the request. */
+    type: 'search' | 'action';
+    /** Extra data given in the app */
+    extra?: any;
+    /** User ID of the calling user */
+    userID: string;
+    /** When type=search, this is the search query */
+    query?: string;
+    /** When type=action, this is the action ID */
+    actionID?: string;
+    /** When type=action, this is the action parameters */
+    parameters?: any;
+}
+/** Format for the response to the webhook when type=search */
+interface KnowledgeBaseWebhookSearchResponse {
+    /** Name for your KB database */
+    name: string;
+    /** Description of your KB database */
+    description?: string;
+    /** Optional icon URL */
+    icon?: string;
+    /** URL to display to open more information about your database */
+    infoURL?: string;
+    /** Items */
+    items: KnowledgeBaseItem[];
+}
+/** Format for the response to the webhook when type=action */
+interface KnowledgeBaseWebhookActionResponse {
+    /** The response to the AI. Can be a text instruction, an error message, a JSON object, anything. */
+    response: any;
+    /** An optional list of knowledge base items to update locally. */
+    updateItems?: KnowledgeBaseItem[];
+}
+
+/** Class to help with logging */
+declare class Logging {
+    /** Current module */
+    module: string;
+    /** Constructor */
+    constructor(moduleName: string);
+    /** Enable debug logging */
+    static debug: boolean;
+    /** Check if verbose logging is enabled */
+    get debugEnabled(): any;
+    /** Log a message */
+    log(...args: any[]): void;
+    /** Debug message */
+    debug(...args: any[]): void;
+    /** Info message message */
+    info(...args: any[]): void;
+    /** Warning message */
+    warn(...args: any[]): void;
+    /** Error message */
+    error(...args: any[]): void;
+    /** Create a timer task, returns a function to log events in this timer */
+    timer(name: string, ...args: any[]): (...args: any[]) => void;
+}
+
+/**
+ * Handles a stream of input/output events with the specified AI model.
+ *
+ * @event event - Fired when an event is emitted, either by the AI or wrapper code etc.
+ */
+declare class IntelliWeaveStream extends IntelliWeave {
+    /** Events that haven't been sent to the AI yet */
+    pendingEvents: IntelliWeaveStreamEvent[];
+    /** Get the system message prefix, before the KB entries are added */
+    getContextPrefix(): Promise<string>;
+    /** Get actions to be added to the context */
+    /** Post an event to the AI */
+    postEvent(event: Partial<IntelliWeaveStreamEvent>): void;
+    /** @private Called when the AI wants to run a KB action */
+    toolRunKBAction(kb: KnowledgeBaseItem, input: any): Promise<any>;
+    /** Output an event to the event listener(s) */
+    private emitEvent;
+    private _isProcessingEvents;
+    /** Process events */
+    private processEvents;
+}
+/** Any event */
+interface IntelliWeaveStreamEvent {
+    /** Event name */
+    eventName: string;
+    /** Event date, unix timestamp, number of milliseconds since Jan 1 1970 */
+    timestamp: number;
+    /** Human-readable event date */
+    timestampDate: string;
+    /** Direction of this event. Input events go into the AI for processing, output events come out of the AI system. */
+    direction: 'input' | 'output';
+    /** Assistant hint, added automatically if there's a KB entry with the same ID. */
+    assistantHint?: string;
+    /** Any extra data */
+    [key: string]: any;
+}
+/** Error event schema */
+interface IntelliWeaveStreamErrorEvent extends IntelliWeaveStreamEvent {
+    /** Event name */
+    eventName: "error";
+    /** Error details */
+    errorMessage: string;
+}
+/** AI speaking event */
+interface IntelliWeaveStreamTextOutputEvent extends IntelliWeaveStreamEvent {
+    /** Event name */
+    eventName: "text";
+    /** The text spoken */
+    text: string;
+}
+
+export { type BufferType, BufferedWebSocket, ChatGPT, type ChatGPTConfig, type ChatGPTToolConfig, FixedBufferStream, IntelliWeave, IntelliWeaveStream, type IntelliWeaveStreamErrorEvent, type IntelliWeaveStreamEvent, type IntelliWeaveStreamTextOutputEvent, KnowledgeBase, type KnowledgeBaseItem, type KnowledgeBaseSource, type KnowledgeBaseWebhookActionResponse, type KnowledgeBaseWebhookRequest, type KnowledgeBaseWebhookSearchResponse, Logging, ONNXModel, type ONNXTensors, Resampler, type WebWeaverGPTConfig, audioToWav, floatTo16BitPCM, floatTo64BitPCM, getDefaultUserID, int16ToFloat32BitPCM, intelliweaveConfig, intelliweaveGlobalThis, sseEvents, trimWhitespaceInText };