dist¶

Interfaces¶

DeepgramJsonObject¶

Indexable¶

[key: string]: DeepgramJsonValue

DeepgramRawClient¶

Properties¶

listen?¶

optional listen?: {
  v1?: {
     media?: {
        transcribeFile:   | HttpResponsePromise<MediaTranscribeResponse>
           | PromiseLike<DeepgramJsonObject>;
     };
  };
};

v1?¶

optional v1?: {
  media?: {
     transcribeFile:   | HttpResponsePromise<MediaTranscribeResponse>
        | PromiseLike<DeepgramJsonObject>;
  };
};

v1.media?¶

optional media?: {
  transcribeFile:   | HttpResponsePromise<MediaTranscribeResponse>
     | PromiseLike<DeepgramJsonObject>;
};

v1.media.transcribeFile()¶

transcribeFile(
   uploadable,
   request,
   requestOptions?):
  | HttpResponsePromise<MediaTranscribeResponse>
| PromiseLike<DeepgramJsonObject>;

Parameters¶

Parameter	Type
`uploadable`	`Uploadable`
`request`	`MediaTranscribeRequestOctetStream`
`requestOptions?`	`RequestOptions`

Returns¶

| HttpResponsePromise\<MediaTranscribeResponse> | PromiseLike\<DeepgramJsonObject>

speak?¶

optional speak?: {
  v1?: {
     audio?: {
        generate:   | HttpResponsePromise<BinaryResponse>
           | PromiseLike<
           | Response
           | ArrayBuffer
           | Uint8Array<ArrayBufferLike>
           | BinaryResponse>;
     };
  };
};

v1?¶

optional v1?: {
  audio?: {
     generate:   | HttpResponsePromise<BinaryResponse>
        | PromiseLike<
        | Response
        | ArrayBuffer
        | Uint8Array<ArrayBufferLike>
        | BinaryResponse>;
  };
};

v1.audio?¶

optional audio?: {
  generate:   | HttpResponsePromise<BinaryResponse>
     | PromiseLike<
     | Response
     | ArrayBuffer
     | Uint8Array<ArrayBufferLike>
     | BinaryResponse>;
};

v1.audio.generate()¶

generate(request, requestOptions?):
  | HttpResponsePromise<BinaryResponse>
  | PromiseLike<
  | Response
  | ArrayBuffer
  | Uint8Array<ArrayBufferLike>
| BinaryResponse>;

Parameters¶

Parameter	Type
`request`	`SpeakV1Request`
`requestOptions?`	`RequestOptions`

Returns¶

DeepgramTextToSpeechInput¶

Properties¶

container?¶

optional container?: string;

encoding?¶

optional encoding?: string;

model?¶

optional model?: string;

sampleRate?¶

optional sampleRate?: number;

signal?¶

optional signal?: AbortSignal;

text¶

text: string;

DeepgramTextToSpeechResult¶

Properties¶

audio¶

audio: ArrayBuffer;

charCount?¶

optional charCount?: number;

contentType?¶

optional contentType?: string;

modelName?¶

optional modelName?: string;

modelUuid?¶

optional modelUuid?: string;

requestId?¶

optional requestId?: string;

DeepgramTranscribeAudioInput¶

Properties¶

audio¶

audio: Uint8Array;

detectLanguage?¶

optional detectLanguage?: boolean;

language?¶

optional language?: string;

model?¶

optional model?: string;

punctuate?¶

optional punctuate?: boolean;

sampleRate?¶

optional sampleRate?: number;

signal?¶

optional signal?: AbortSignal;

smartFormat?¶

optional smartFormat?: boolean;

DeepgramTranscriptionResult¶

Properties¶

channels?¶

optional channels?: number;

confidence?¶

optional confidence?: number;

duration?¶

optional duration?: number;

modelName?¶

optional modelName?: string;

raw?¶

optional raw?: DeepgramJsonObject;

requestId?¶

optional requestId?: string;

text¶

text: string;

DeepgramVoiceClient¶

Methods¶

getRawClient()¶

getRawClient(): Promise<DeepgramRawClient>;

Returns¶

Promise\<DeepgramRawClient>

getSdkClient()¶

getSdkClient(): Promise<DeepgramRawClient>;

Returns¶

Promise\<DeepgramRawClient>

synthesizeSpeech()¶

synthesizeSpeech(input): Promise<DeepgramTextToSpeechResult>;

Parameters¶

Parameter	Type
`input`	`DeepgramTextToSpeechInput`

Returns¶

Promise\<DeepgramTextToSpeechResult>

transcribeAudio()¶

transcribeAudio(input): Promise<DeepgramTranscriptionResult>;

Parameters¶

Parameter	Type
`input`	`DeepgramTranscribeAudioInput`

Returns¶

Promise\<DeepgramTranscriptionResult>

DeepgramVoiceClientOptions¶

Properties¶

apiBaseUrl?¶

optional apiBaseUrl?: string;

apiKey?¶

optional apiKey?: string;

fetch?¶

optional fetch?: {
  (input, init?): Promise<Response>;
  (input, init?): Promise<Response>;
};

Call Signature¶

(input, init?): Promise<Response>;

MDN Reference

Parameters¶

Parameter	Type
`input`	`URL` \| `RequestInfo`
`init?`	`RequestInit`

Returns¶

Promise\<Response>

Call Signature¶

(input, init?): Promise<Response>;

MDN Reference

Parameters¶

Parameter	Type
`input`	`string` \| `Request` \| `URL`
`init?`	`RequestInit`

Returns¶

Promise\<Response>

rawClient?¶

optional rawClient?: DeepgramRawClient;

DeepgramVoiceProviderOptions¶

Extends¶

Omit\<Partial\<SpeechPipelineVoiceProviderOptions>, "provider" | "transcriptionSource" | "transcribe" | "synthesize">

Indexable¶

[key: string]: SpeechPipelineVoiceProviderOptions

[key: number]: SpeechPipelineVoiceProviderOptions

[key: symbol]: SpeechPipelineVoiceProviderOptions

Properties¶

apiBaseUrl?¶

optional apiBaseUrl?: string;

apiKey?¶

optional apiKey?: string;

client?¶

optional client?: DeepgramVoiceClient;

container?¶

optional container?: string;

detectLanguage?¶

optional detectLanguage?: boolean;

encoding?¶

optional encoding?: string;

fetch?¶

optional fetch?: {
  (input, init?): Promise<Response>;
  (input, init?): Promise<Response>;
};

Call Signature¶

(input, init?): Promise<Response>;

MDN Reference

Parameters¶

Parameter	Type
`input`	`URL` \| `RequestInfo`
`init?`	`RequestInit`

Returns¶

Promise\<Response>

Call Signature¶

(input, init?): Promise<Response>;

MDN Reference

Parameters¶

Parameter	Type
`input`	`string` \| `Request` \| `URL`
`init?`	`RequestInit`

Returns¶

Promise\<Response>

language?¶

optional language?: string;

outputSampleRate?¶

optional outputSampleRate?: number;

punctuate?¶

optional punctuate?: boolean;

rawClient?¶

optional rawClient?: DeepgramRawClient;

smartFormat?¶

optional smartFormat?: boolean;

speechToTextModel?¶

optional speechToTextModel?: string;

textToSpeechModel?¶

optional textToSpeechModel?: string;

Type Aliases¶

DeepgramJsonPrimitive¶

type DeepgramJsonPrimitive = string | number | boolean | null;

DeepgramJsonValue¶

type DeepgramJsonValue =
  | DeepgramJsonPrimitive
  | DeepgramJsonObject
  | DeepgramJsonValue[];

Variables¶

deepgramVoiceIntegration¶

const deepgramVoiceIntegration: DefinedIntegration<{
  capabilities: {
     audiences?: ("customer-facing" | "mixed" | "internal-support")[];
     capability: string;
     changesWorkflow?: boolean;
     description?: string;
     exposesSensitiveData?: boolean;
     extension?: boolean;
     label?: string;
     metadata?: Record<string, unknown>;
     providerObjects?: {
        description?: string;
        kind: string;
        label?: string;
        metadata?: Record<string, unknown>;
        schemaName?: string;
     }[];
     requiresCredential?: boolean;
     sideEffect?: boolean;
  }[];
  category: string;
  channelAudiences: ("customer-facing" | "mixed" | "internal-support")[];
  coverage: {
     evidence: {
        label: string;
        url?: string;
     }[];
     notes: string[];
     scope:   | "provider-api-subset"
        | "support-workflow-subset"
        | "connector-required"
        | "local-protocol"
        | "full-provider-api";
  };
  credentialRequirements: {
     description?: string;
     id: string;
     label?: string;
     metadata?: Record<string, unknown>;
     required: boolean;
     scopes: string[];
  }[];
  directions: (
     | "receive-only"
     | "send-only"
     | "bidirectional"
     | "inbound-only"
    | "outbound-only")[];
  id: string;
  limitations: string[];
  maintainers: {
     name: string;
     type: "official" | "community" | "unknown" | "partner";
     url?: string;
  }[];
  metadata?: Record<string, unknown>;
  name: string;
  operations: {
     alias: string;
     audience?: "customer-facing" | "mixed" | "internal-support";
     audiences?: ("customer-facing" | "mixed" | "internal-support")[];
     capability: string;
     changesWorkflow?: boolean;
     description?: string;
     exposesSensitiveData?: boolean;
     extension: boolean;
     externallyVisible?: boolean;
     inputSchema?: unknown;
     inputSchemaName?: string;
     inputSchemaRef?: string;
     label?: string;
     metadata?: Record<string, unknown>;
     outputSchema?: unknown;
     outputSchemaName?: string;
     outputSchemaRef?: string;
     providerObject?: string;
     providerObjects?: {
        description?: string;
        kind: string;
        label?: string;
        metadata?: Record<string, unknown>;
        schemaName?: string;
     }[];
     providerOperation?: string;
     requiredPolicyIds?: string[];
     requiresApproval?: boolean;
     requiresCredential?: boolean;
     sideEffect?: boolean;
  }[];
  packageName: string;
  privacyNotes: string[];
  provider: string;
  trustLevel: "official" | "community" | "verified" | "experimental";
} & {
  capabilities: readonly [{
     audiences: readonly ["customer-facing"];
     capability: "receive";
     description: "Transcribes customer PCM/WAV voice input with Deepgram speech-to-text.";
     exposesSensitiveData: true;
     label: "Transcribe speech";
     providerObjects: readonly [{
        kind: "deepgramTranscript";
        label: "Deepgram Transcript";
     }];
     requiresCredential: true;
   }, {
     audiences: readonly ["customer-facing"];
     capability: "send";
     description: "Synthesizes Cognidesk assistant text with Deepgram text-to-speech.";
     exposesSensitiveData: true;
     label: "Synthesize speech";
     providerObjects: readonly [{
        kind: "deepgramSpeechSynthesis";
        label: "Deepgram Speech Synthesis";
     }];
     requiresCredential: true;
     sideEffect: true;
   }, {
     audiences: readonly ["customer-facing", "internal-support"];
     capability: "media";
     description: "Exchanges buffered PCM input and synthesized audio for Cognidesk voice sessions.";
     exposesSensitiveData: true;
     label: "Speech audio media";
     providerObjects: readonly [{
        kind: "voiceTranscript";
        label: "Voice Transcript";
      }, {
        kind: "voiceAudio";
        label: "Voice Audio";
     }];
     requiresCredential: true;
  }];
  category: "voice";
  channelAudiences: readonly ["customer-facing", "mixed"];
  coverage: {
     evidence: readonly [{
        label: "Deepgram SDK package";
        url: "https://www.npmjs.com/package/@deepgram/sdk";
      }, {
        label: "Deepgram prerecorded audio STT";
        url: "https://developers.deepgram.com/docs/pre-recorded-audio";
      }, {
        label: "Deepgram Text-to-Speech REST";
        url: "https://developers.deepgram.com/docs/text-to-speech";
     }];
     notes: readonly ["Implements normalized Cognidesk speech-to-text and text-to-speech operations with the official Deepgram SDK.", "Raw Deepgram SDK access is exposed as an escape hatch, but Cognidesk does not claim ownership of the full Deepgram provider API.", "Deepgram Voice Agent, Flux streaming sessions, account administration, telephony setup, self-hosted deployment management, and custom model administration remain outside this normalized adapter."];
     scope: "provider-api-subset";
  };
  credentialRequirements: readonly [{
     description: "Server-side Deepgram API key used by the official SDK for speech API requests.";
     id: "deepgram-api-key";
     label: "Deepgram API key";
     metadata: {
        minimumAccess: readonly ["speech-to-text", "text-to-speech"];
        scopeKind: "provider-permission";
     };
     required: true;
  }];
  directions: readonly ["receive-only", "send-only", "bidirectional"];
  id: "voice.deepgram";
  limitations: readonly ["This package implements SDK-backed STT/TTS for Cognidesk speech pipelines, not Deepgram Voice Agent or Flux websocket sessions.", "The background LLM is the Cognidesk Agent Model Set, not Deepgram."];
  maintainers: readonly [{
     name: "Cognidesk";
     type: "official";
  }];
  metadata: {
     implementation: {
        sdkPackage: "@deepgram/sdk";
        strategy: "official-sdk";
        verifiedAt: "2026-06-21";
        verifiedVersion: "5.4.0";
     };
     rawClient: {
        coverage: "upstream-sdk";
        export: "getRawClient";
     };
  };
  name: "Deepgram Voice";
  operations: readonly [{
     alias: "voice.turn.finalize";
     audiences: readonly ["customer-facing"];
     capability: "receive";
     exposesSensitiveData: true;
     label: "Transcribe speech";
     providerObject: "voiceTranscript";
     providerOperation: "listen.v1.media.transcribeFile";
   }, {
     alias: "voice.speak";
     audiences: readonly ["customer-facing"];
     capability: "send";
     exposesSensitiveData: true;
     label: "Synthesize speech";
     providerObject: "voiceAudio";
     providerOperation: "speak.v1.audio.generate";
     sideEffect: true;
  }];
  packageName: "@cognidesk/integration-voice-deepgram";
  privacyNotes: readonly ["Customer audio is sent to Deepgram for transcription, and assistant response text is sent to Deepgram for synthesis.", "Deepgram API keys remain server-side and are never issued to browsers by this package."];
  provider: "deepgram";
  trustLevel: "official";
}, unknown, {
  voice.speak: (input, context) => Promise<DeepgramTextToSpeechResult>;
  voice.turn.finalize: (input, context) => Promise<DeepgramTranscriptionResult>;
}>;

Functions¶

createDeepgramVoiceClient()¶

function createDeepgramVoiceClient(options): DeepgramVoiceClient;

Parameters¶

Parameter	Type
`options`	`DeepgramVoiceClientOptions`

Returns¶

DeepgramVoiceClient

createDeepgramVoiceProvider()¶

function createDeepgramVoiceProvider(options?): VoiceProvider;

Parameters¶

Parameter	Type
`options?`	`DeepgramVoiceProviderOptions`

Returns¶

VoiceProvider

deepgramVoiceCredentialStatuses()¶

function deepgramVoiceCredentialStatuses(input): {
  expiresAt?: string;
  message?: string;
  providerPackageId?: string;
  requirementId: string;
  scopes?: string[];
  state:   | "required"
     | "configured"
     | "permission-blocked"
     | "not-required"
     | "missing"
     | "expired"
     | "insufficient-scope"
     | "unavailable";
}[];

Parameters¶

Parameter	Type
`input`	{ `apiKey?`: `string`; }
`input.apiKey?`	`string`

Returns¶

{ expiresAt?: string; message?: string; providerPackageId?: string; requirementId: string; scopes?: string[]; state: | "required" | "configured" | "permission-blocked" | "not-required" | "missing" | "expired" | "insufficient-scope" | "unavailable"; }[]

References¶

deepgramVoiceProviderManifest¶

Re-exports deepgramVoiceProviderManifest