@deepgram/sdk 3.0.0 → 3.1.3

package/src/lib/types/SyncPrerecordedResponse.ts

@@ -18,6 +18,7 @@ interface Channel {
   search?: Search[];
   alternatives: Alternative[];
   detected_language?: string;
+  language_confidence?: number;
 }
 
 interface Entity {
@@ -43,8 +44,15 @@ interface Metadata {
   duration: number;
   channels: number;
   models: string[];
-  model_info: Record<string, ModelInfo>;
   warnings?: Warning[];
+  model_info: Record<string, ModelInfo>;
+  summary_info?: SummaryInfo;
+  intents_info?: IntentsInfo;
+  sentiment_info?: SentimentInfo;
+  topics_info?: TopicsInfo;
+  extra: {
+    [key: string]: unknown;
+  };
 }
 
 interface ModelInfo {
@@ -53,6 +61,30 @@ interface ModelInfo {
   arch: string;
 }
 
+interface SummaryInfo {
+  input_tokens: number;
+  output_tokens: number;
+  model_uuid: string;
+}
+
+interface IntentsInfo {
+  model_uuid: string;
+  input_tokens: number;
+  output_tokens: number;
+}
+
+interface SentimentInfo {
+  model_uuid: string;
+  input_tokens: number;
+  output_tokens: number;
+}
+
+interface TopicsInfo {
+  model_uuid: string;
+  input_tokens: number;
+  output_tokens: number;
+}
+
 interface Paragraph {
   sentences: Sentence[];
   start: number;
@@ -69,6 +101,47 @@ interface Result {
   channels: Channel[];
   utterances?: Utterance[];
   summary?: TranscriptionSummary;
+  sentiments?: Sentiments;
+  topics?: Topics;
+  intents?: Intents;
+}
+
+interface Sentiments {
+  segments: Segment[];
+  average: Average;
+}
+
+interface Topics {
+  segments: Segment[];
+}
+
+interface Intents {
+  segments: Segment[];
+}
+
+interface Intent {
+  intent: string;
+  confidence_score: number;
+}
+
+interface Average {
+  sentiment: string;
+  sentiment_score: number;
+}
+
+interface Topic {
+  topic: string;
+  confidence_score: number;
+}
+
+interface Segment {
+  text: string;
+  start_word: number;
+  end_word: number;
+  sentiment?: string;
+  sentiment_score?: number;
+  topics?: Topic[];
+  intents?: Intent[];
 }
 
 interface Search {

package/src/lib/types/TranscriptionSchema.ts

@@ -8,6 +8,7 @@ interface TranscriptionSchema extends Record<string, unknown> {
   model?: string;
 
   /**
+   * @deprecated
    * @see https://developers.deepgram.com/docs/tier
    */
   tier?: string;
@@ -42,11 +43,21 @@ interface TranscriptionSchema extends Record<string, unknown> {
    */
   diarize?: boolean;
 
+  /**
+   * @see https://developers.deepgram.com/docs/diarization
+   */
+  diarize_version?: string;
+
   /**
    * @see https://developers.deepgram.com/docs/smart-format
    */
   smart_format?: boolean;
 
+  /**
+   * @see https://developers.deepgram.com/docs/filler-words
+   */
+  filler_words?: boolean;
+
   /**
    * @see https://developers.deepgram.com/docs/multichannel
    */
@@ -73,6 +84,11 @@ interface TranscriptionSchema extends Record<string, unknown> {
    */
   callback?: string;
 
+  /**
+   * @see https://developers.deepgram.com/docs/callback#results
+   */
+  callback_method?: string;
+
   /**
    * @see https://developers.deepgram.com/docs/keywords
    */
@@ -83,6 +99,46 @@ interface TranscriptionSchema extends Record<string, unknown> {
    */
   tag?: string[];
 
+  /**
+   * As yet unreleased.
+   */
+  sentiment?: boolean;
+
+  /**
+   * As yet unreleased.
+   */
+  intents?: boolean;
+
+  /**
+   * As yet unreleased.
+   */
+  custom_intent?: string[] | string;
+
+  /**
+   * As yet unreleased.
+   */
+  custom_intent_mode?: "strict" | "extended";
+
+  /**
+   * As yet unreleased.
+   */
+  topics?: boolean;
+
+  /**
+   * As yet unreleased.
+   */
+  custom_topic?: string[] | string;
+
+  /**
+   * As yet unreleased.
+   */
+  custom_topic_mode?: "strict" | "extended";
+
+  /**
+   * @see https://developers.deepgram.com/docs/extra
+   */
+  extra?: boolean;
+
   [key: string]: unknown;
 }
 
@@ -103,7 +159,11 @@ interface PrerecordedSchema extends TranscriptionSchema {
   detect_topics?: boolean;
 
   /**
-   * Undocumented feature.
+   * Alternatives will run your transcription X number of times and return
+   * that many variations of the transcription, allowing for the selection
+   * of the most accurate. Cost increases by number of alternatives.
+   *
+   * @deprecated
    */
   alternatives?: number;
 
@@ -126,6 +186,16 @@ interface PrerecordedSchema extends TranscriptionSchema {
    * @see https://developers.deepgram.com/docs/utterance-split
    */
   utt_split?: number;
+
+  /**
+   * @see https://developers.deepgram.com/docs/smart-format#dictation
+   */
+  dictation?: boolean;
+
+  /**
+   * @see https://developers.deepgram.com/docs/smart-format#measurements
+   */
+  measurements?: boolean;
 }
 
 interface LiveSchema extends TranscriptionSchema {
@@ -147,12 +217,22 @@ interface LiveSchema extends TranscriptionSchema {
   /**
    * @see https://developers.deepgram.com/docs/endpointing
    */
-  endpointing?: number;
+  endpointing?: false | number;
 
   /**
    * @see https://developers.deepgram.com/docs/interim-results
    */
   interim_results?: boolean;
+
+  /**
+   * @see https://developers.deepgram.com/docs/understanding-end-of-speech-detection
+   */
+  utterance_end_ms?: number;
+
+  /**
+   * @see https://developers.deepgram.com/docs/start-of-speech-detection
+   */
+  vad_events?: boolean;
 }
 
 export type { TranscriptionSchema, PrerecordedSchema, LiveSchema };

package/src/lib/types/UtteranceEndEvent.ts

@@ -0,0 +1,5 @@
+export interface UtteranceEndEvent {
+  type: "UtteranceEnd";
+  channel: number[];
+  last_word_end: number;
+}

package/src/lib/types/index.ts

@@ -1,4 +1,6 @@
+export type { AnalyzeSchema } from "./AnalyzeSchema";
 export type { AsyncPrerecordedResponse } from "./AsyncPrerecordedResponse";
+export type { AsyncAnalyzeResponse } from "./AsyncAnalyzeResponse";
 export type { CreateOnPremCredentialsSchema } from "./CreateOnPremCredentialsSchema";
 export type { CreateProjectKeySchema } from "./CreateProjectKeySchema";
 export type { CreateProjectKeyResponse } from "./CreateProjectKeyResponse";
@@ -32,10 +34,19 @@ export type { LiveConfigOptions } from "./LiveConfigOptions";
 export type { LiveMetadataEvent } from "./LiveMetadataEvent";
 export type { LiveTranscriptionEvent } from "./LiveTranscriptionEvent";
 export type { MessageResponse } from "./MessageResponse";
-export type { FileSource, PrerecordedSource, UrlSource } from "./PrerecordedSource";
+export type {
+  FileSource,
+  PrerecordedSource,
+  UrlSource,
+  TextSource,
+  AnalyzeSource,
+} from "./DeepgramSource";
 export type { SendProjectInviteSchema } from "./SendProjectInviteSchema";
+export type { SpeechStartedEvent } from "./SpeechStartedEvent";
 export type { SyncPrerecordedResponse } from "./SyncPrerecordedResponse";
+export type { SyncAnalyzeResponse } from "./SyncAnalyzeResponse";
 export type { TranscriptionSchema, PrerecordedSchema, LiveSchema } from "./TranscriptionSchema";
 export type { UpdateProjectMemberScopeSchema } from "./UpdateProjectMemberScopeSchema";
 export type { UpdateProjectSchema } from "./UpdateProjectSchema";
+export type { UtteranceEndEvent } from "./UtteranceEndEvent";
 export type { VoidResponse } from "./VoidResponse";

package/src/lib/version.ts

@@ -1 +1 @@
-export const version = "3.0.0";
+export const version = "3.1.3";

package/src/packages/AbstractClient.ts

@@ -31,21 +31,46 @@ export abstract class AbstractClient {
       );
     }
 
-    if (this.willProxy()) {
+    let baseUrlString: string = this.options.global.url;
+    let proxyUrlString: string;
+
+    /**
+     * Check if the base URL provided is missing a protocol and warn in the console.
+     */
+    if (!baseUrlString.startsWith("http") && !baseUrlString.startsWith("ws")) {
+      console.warn(
+        `The base URL provided does not begin with http, https, ws, or wss and will default to https as standard.`
+      );
+    }
+
+    /**
+     * Applying proxy to base URL.
+     */
+    if (this.options.restProxy?.url) {
+      /**
+       * Prevent client using a real API key when using a proxy configuration.
+       */
       if (this.key !== "proxy") {
         throw new DeepgramError(
           `Do not attempt to pass any other API key than the string "proxy" when making proxied REST requests. Please ensure your proxy application is responsible for writing our API key to the Authorization header.`
         );
       }
 
-      this.baseUrl = this.resolveBaseUrl(this.options.restProxy?.url as string);
+      proxyUrlString = this.options.restProxy.url;
 
-      if (this.options.global.headers) {
-        this.options.global.headers["X-Deepgram-Proxy"] = this.options.global.url;
+      /**
+       * Check if the proxy URL provided is missing a protocol and warn in the console.
+       */
+      if (!proxyUrlString.startsWith("http") && !proxyUrlString.startsWith("ws")) {
+        console.warn(
+          `The proxy URL provided does not begin with http, https, ws, or wss and will default to https as standard.`
+        );
       }
-    } else {
-      this.baseUrl = this.resolveBaseUrl(this.options.global.url);
+
+      baseUrlString = proxyUrlString;
     }
+
+    this.baseUrl = this.resolveBaseUrl(baseUrlString);
   }
 
   protected resolveBaseUrl(url: string) {

package/src/packages/AbstractRestfulClient.ts

@@ -12,7 +12,7 @@ export abstract class AbstractRestfulClient extends AbstractClient {
   constructor(protected key: string, protected options: DeepgramClientOptions) {
     super(key, options);
 
-    if (isBrowser() && !this.willProxy()) {
+    if (isBrowser() && !this._willProxy()) {
       throw new DeepgramError(
         "Due to CORS we are unable to support REST-based API calls to our API from the browser. Please consider using a proxy, and including a `restProxy: { url: ''}` in your Deepgram client options."
       );
@@ -130,4 +130,10 @@ export abstract class AbstractRestfulClient extends AbstractClient {
   ): Promise<any> {
     return this._handleRequest(fetcher, "DELETE", url, headers, parameters);
   }
+
+  private _willProxy() {
+    const proxyUrl = this.options.restProxy?.url;
+
+    return !!proxyUrl;
+  }
 }

package/src/packages/LiveClient.ts

@@ -11,6 +11,8 @@ import type {
   LiveMetadataEvent,
   LiveTranscriptionEvent,
   DeepgramClientOptions,
+  UtteranceEndEvent,
+  SpeechStartedEvent,
 } from "../lib/types";
 
 export class LiveClient extends AbstractWsClient {
@@ -35,17 +37,6 @@ export class LiveClient extends AbstractWsClient {
     };
 
     this._socket.onclose = (event: any) => {
-      /**
-       * changing the event.target to any to access the private _req
-       * property that isn't available on the WebSocket.CloseEvent type
-       **/
-      const newTarget: any = event.target;
-
-      if (newTarget["_req"]) {
-        const dgErrorIndex = newTarget["_req"].res.rawHeaders.indexOf("dg-error");
-        event.reason = newTarget["_req"].res.rawHeaders[dgErrorIndex + 1];
-      }
-
       this.emit(LiveTranscriptionEvents.Close, event);
     };
 
@@ -64,6 +55,14 @@ export class LiveClient extends AbstractWsClient {
         if (data.type === LiveTranscriptionEvents.Transcript) {
           this.emit(LiveTranscriptionEvents.Transcript, data as LiveTranscriptionEvent);
         }
+
+        if (data.type === LiveTranscriptionEvents.UtteranceEnd) {
+          this.emit(LiveTranscriptionEvents.UtteranceEnd, data as UtteranceEndEvent);
+        }
+
+        if (data.type === LiveTranscriptionEvents.SpeechStarted) {
+          this.emit(LiveTranscriptionEvents.SpeechStarted, data as SpeechStartedEvent);
+        }
       } catch (error) {
         this.emit(LiveTranscriptionEvents.Error, {
           event,

package/src/packages/PrerecordedClient.ts

@@ -28,7 +28,7 @@ export class PrerecordedClient extends AbstractRestfulClient {
 
       if (options !== undefined && "callback" in options) {
         throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous transcription. Use `asyncPrerecordedUrl` or `asyncPrerecordedFile` instead."
+          "Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead."
         );
       }
 
@@ -65,7 +65,7 @@ export class PrerecordedClient extends AbstractRestfulClient {
 
       if (options !== undefined && "callback" in options) {
         throw new DeepgramError(
-          "Callback cannot be provided as an option to a synchronous transcription. Use `asyncPrerecordedUrl` or `asyncPrerecordedFile` instead."
+          "Callback cannot be provided as an option to a synchronous transcription. Use `transcribeUrlCallback` or `transcribeFileCallback` instead."
         );
       }
 

package/src/packages/ReadClient.ts

@@ -0,0 +1,161 @@
+import { AbstractRestfulClient } from "./AbstractRestfulClient";
+import { CallbackUrl, appendSearchParams, isTextSource, isUrlSource } from "../lib/helpers";
+import { DeepgramError, isDeepgramError } from "../lib/errors";
+import type {
+  AnalyzeSchema,
+  AsyncAnalyzeResponse,
+  DeepgramResponse,
+  Fetch,
+  PrerecordedSchema,
+  SyncAnalyzeResponse,
+  TextSource,
+  UrlSource,
+} from "../lib/types";
+
+export class ReadClient extends AbstractRestfulClient {
+  async analyzeUrl(
+    source: UrlSource,
+    options?: AnalyzeSchema,
+    endpoint = "v1/read"
+  ): Promise<DeepgramResponse<SyncAnalyzeResponse>> {
+    try {
+      let body;
+
+      if (isUrlSource(source)) {
+        body = JSON.stringify(source);
+      } else {
+        throw new DeepgramError("Unknown source type");
+      }
+
+      if (options !== undefined && "callback" in options) {
+        throw new DeepgramError(
+          "Callback cannot be provided as an option to a synchronous transcription. Use `analyzeUrlCallback` or `analyzeTextCallback` instead."
+        );
+      }
+
+      const analyzeOptions: AnalyzeSchema = { ...{}, ...options };
+
+      const url = new URL(endpoint, this.baseUrl);
+      appendSearchParams(url.searchParams, analyzeOptions);
+
+      const result: SyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
+
+      return { result, error: null };
+    } catch (error) {
+      if (isDeepgramError(error)) {
+        return { result: null, error };
+      }
+
+      throw error;
+    }
+  }
+
+  async analyzeText(
+    source: TextSource,
+    options?: AnalyzeSchema,
+    endpoint = "v1/read"
+  ): Promise<DeepgramResponse<SyncAnalyzeResponse>> {
+    try {
+      let body;
+
+      if (isTextSource(source)) {
+        body = JSON.stringify(source);
+      } else {
+        throw new DeepgramError("Unknown source type");
+      }
+
+      if (options !== undefined && "callback" in options) {
+        throw new DeepgramError(
+          "Callback cannot be provided as an option to a synchronous requests. Use `analyzeUrlCallback` or `analyzeTextCallback` instead."
+        );
+      }
+
+      const analyzeOptions: AnalyzeSchema = { ...{}, ...options };
+
+      const url = new URL(endpoint, this.baseUrl);
+      appendSearchParams(url.searchParams, analyzeOptions);
+
+      const result: SyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
+
+      return { result, error: null };
+    } catch (error) {
+      if (isDeepgramError(error)) {
+        return { result: null, error };
+      }
+
+      throw error;
+    }
+  }
+
+  async analyzeUrlCallback(
+    source: UrlSource,
+    callback: CallbackUrl,
+    options?: AnalyzeSchema,
+    endpoint = "v1/read"
+  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
+    try {
+      let body;
+
+      if (isUrlSource(source)) {
+        body = JSON.stringify(source);
+      } else {
+        throw new DeepgramError("Unknown source type");
+      }
+
+      const transcriptionOptions: PrerecordedSchema = {
+        ...options,
+        ...{ callback: callback.toString() },
+      };
+
+      const url = new URL(endpoint, this.baseUrl);
+      appendSearchParams(url.searchParams, transcriptionOptions);
+
+      const result: AsyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body);
+
+      return { result, error: null };
+    } catch (error) {
+      if (isDeepgramError(error)) {
+        return { result: null, error };
+      }
+
+      throw error;
+    }
+  }
+
+  async analyzeTextCallback(
+    source: TextSource,
+    callback: CallbackUrl,
+    options?: AnalyzeSchema,
+    endpoint = "v1/read"
+  ): Promise<DeepgramResponse<AsyncAnalyzeResponse>> {
+    try {
+      let body;
+
+      if (isTextSource(source)) {
+        body = JSON.stringify(source);
+      } else {
+        throw new DeepgramError("Unknown source type");
+      }
+
+      const transcriptionOptions: PrerecordedSchema = {
+        ...options,
+        ...{ callback: callback.toString() },
+      };
+
+      const url = new URL(endpoint, this.baseUrl);
+      appendSearchParams(url.searchParams, transcriptionOptions);
+
+      const result: AsyncAnalyzeResponse = await this.post(this.fetch as Fetch, url, body, {
+        "Content-Type": "deepgram/audio+video",
+      });
+
+      return { result, error: null };
+    } catch (error) {
+      if (isDeepgramError(error)) {
+        return { result: null, error };
+      }
+
+      throw error;
+    }
+  }
+}

package/dist/main/lib/types/PrerecordedSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrerecordedSource.d.ts","sourceRoot":"","sources":["../../../../src/lib/types/PrerecordedSource.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,oBAAY,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9D,oBAAY,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3C,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;CACb"}

package/dist/main/lib/types/PrerecordedSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrerecordedSource.js","sourceRoot":"","sources":["../../../../src/lib/types/PrerecordedSource.ts"],"names":[],"mappings":""}

package/dist/module/lib/types/PrerecordedSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrerecordedSource.d.ts","sourceRoot":"","sources":["../../../../src/lib/types/PrerecordedSource.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,oBAAY,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9D,oBAAY,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3C,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;CACb"}

package/dist/module/lib/types/PrerecordedSource.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=PrerecordedSource.js.map

package/dist/module/lib/types/PrerecordedSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PrerecordedSource.js","sourceRoot":"","sources":["../../../../src/lib/types/PrerecordedSource.ts"],"names":[],"mappings":""}