dist¶

Interfaces¶

OpenAIRealtimeEventSendInput¶

Properties¶

event¶

event: RealtimeClientEvent;

socket¶

socket: OpenAIRealtimeSocket;

OpenAIRealtimeFactoryInput¶

Properties¶

client¶

client: OpenAI;

model¶

model: "gpt-realtime-2";

OpenAIRealtimeSessionStartInput¶

Extends¶

OpenAIRealtimeSocketInput

Properties¶

model?¶

optional model?: string;

Inherited from¶

OpenAIRealtimeSocketInput.model

session?¶

optional session?: RealtimeSessionCreateRequest;

socket?¶

optional socket?: OpenAIRealtimeSocket;

OpenAIRealtimeSessionStartResult¶

Properties¶

session¶

session: RealtimeSessionCreateRequest;

socket¶

socket: OpenAIRealtimeSocket;

OpenAIRealtimeSocket¶

Methods¶

close()¶

close(props?): void;

Parameters¶

Parameter	Type
`props?`	{ `code`: `number`; `reason`: `string`; }
`props.code?`	`number`
`props.reason?`	`string`

Returns¶

void

on()¶

Call Signature¶

on(event, listener): void;

Parameters¶

Parameter	Type
`event`	`"event"`
`listener`	(`event`) => `void`

Returns¶

void

Call Signature¶

on(event, listener): void;

Parameters¶

Parameter	Type
`event`	`"error"`
`listener`	(`error`) => `void`

Returns¶

void

send()¶

send(event): void;

Parameters¶

Parameter	Type
`event`	`RealtimeClientEvent`

Returns¶

void

OpenAIRealtimeSocketInput¶

Extended by¶

OpenAIRealtimeSessionStartInput

Properties¶

model?¶

optional model?: string;

OpenAIRealtimeSpeakInput¶

Properties¶

id?¶

optional id?: string;

response?¶

optional response?: RealtimeResponseCreateParams;

socket¶

socket: OpenAIRealtimeSocket;

text?¶

optional text?: string;

OpenAIRealtimeTurnFinalizeInput¶

Properties¶

eventId?¶

optional eventId?: string;

socket¶

socket: OpenAIRealtimeSocket;

OpenAIVoiceClient¶

Methods¶

commitAudioTurn()¶

commitAudioTurn(input): RealtimeClientEvent;

Parameters¶

Parameter	Type
`input`	`OpenAIRealtimeTurnFinalizeInput`

Returns¶

RealtimeClientEvent

createRealtimeResponse()¶

createRealtimeResponse(input): RealtimeClientEvent;

Parameters¶

Parameter	Type
`input`	{ `response`: `RealtimeResponseCreateParams`; `socket`: `OpenAIRealtimeSocket`; }
`input.response`	`RealtimeResponseCreateParams`
`input.socket`	`OpenAIRealtimeSocket`

Returns¶

RealtimeClientEvent

createRealtimeSocket()¶

createRealtimeSocket(input?): Promise<OpenAIRealtimeSocket>;

Parameters¶

Parameter	Type
`input?`	`OpenAIRealtimeSocketInput`

Returns¶

Promise\<OpenAIRealtimeSocket>

getRawClient()¶

getRawClient(): Promise<OpenAI>;

Returns¶

Promise\<OpenAI>

sendRealtimeEvent()¶

sendRealtimeEvent(input): RealtimeClientEvent;

Parameters¶

Parameter	Type
`input`	`OpenAIRealtimeEventSendInput`

Returns¶

RealtimeClientEvent

speak()¶

speak(input): {
  event: RealtimeClientEvent;
  speechId?: string;
};

Parameters¶

Parameter	Type
`input`	`OpenAIRealtimeSpeakInput`

Returns¶

{
  event: RealtimeClientEvent;
  speechId?: string;
}

Name	Type
`event`	`RealtimeClientEvent`
`speechId?`	`string`

startRealtimeSession()¶

startRealtimeSession(input?): Promise<OpenAIRealtimeSessionStartResult>;

Parameters¶

Parameter	Type
`input?`	`OpenAIRealtimeSessionStartInput`

Returns¶

Promise\<OpenAIRealtimeSessionStartResult>

updateRealtimeSession()¶

updateRealtimeSession(input): RealtimeClientEvent;

Parameters¶

Parameter	Type
`input`	{ `session`: `RealtimeSessionCreateRequest`; `socket`: `OpenAIRealtimeSocket`; }
`input.session`	`RealtimeSessionCreateRequest`
`input.socket`	`OpenAIRealtimeSocket`

Returns¶

RealtimeClientEvent

OpenAIVoiceClientOptions¶

Properties¶

apiKey?¶

optional apiKey?: string;

baseURL?¶

optional baseURL?: string;

rawClient?¶

optional rawClient?: OpenAI;

realtime?¶

optional realtime?: OpenAIRealtimeFactory;

OpenAIVoiceProviderOptions¶

Properties¶

apiKey?¶

optional apiKey?: string;

baseURL?¶

optional baseURL?: string;

client?¶

optional client?: OpenAI;

Raw official OpenAI SDK client. Prefer rawClient for new code.

model?¶

optional model?: "gpt-realtime-2";

rawClient?¶

optional rawClient?: OpenAI;

realtime?¶

optional realtime?: OpenAIRealtimeFactory;

sessionDefaults?¶

optional sessionDefaults?: Partial<RealtimeSessionCreateRequest>;

transcriptionLanguage?¶

optional transcriptionLanguage?: string;

voice?¶

optional voice?: string;

voiceClient?¶

optional voiceClient?: OpenAIVoiceClient;

Type Aliases¶

OpenAIRealtimeFactory¶

type OpenAIRealtimeFactory = (input) => Promise<OpenAIRealtimeSocket>;

Parameters¶

Parameter	Type
`input`	`OpenAIRealtimeFactoryInput`

Returns¶

Promise\<OpenAIRealtimeSocket>

OpenAIRealtimeResponseCreateRequest¶

type OpenAIRealtimeResponseCreateRequest = NonNullable<Extract<RealtimeClientEvent, {
  type: "response.create";
}>["response"]>;

Variables¶

createOpenAIVoiceAdapter¶

const createOpenAIVoiceAdapter: typeof createOpenAIVoiceProvider;

openAIVoiceIntegration¶

const openAIVoiceIntegration: DefinedIntegration<{
  capabilities: (
     | {
     audiences: "customer-facing"[];
     capability: string;
     changesWorkflow?: never;
     description: string;
     exposesSensitiveData: true;
     label: string;
     providerObjects: {
        kind: string;
        label: string;
     }[];
     requiresCredential: true;
     sideEffect?: never;
   }
     | {
     audiences: "customer-facing"[];
     capability: string;
     changesWorkflow?: never;
     description: string;
     exposesSensitiveData: true;
     label: string;
     providerObjects: {
        kind: string;
        label: string;
     }[];
     requiresCredential: true;
     sideEffect: true;
   }
     | {
     audiences: ("customer-facing" | "internal-support")[];
     capability: string;
     changesWorkflow: true;
     description: string;
     exposesSensitiveData?: never;
     label: string;
     providerObjects: {
        kind: string;
        label: string;
     }[];
     requiresCredential: true;
     sideEffect: true;
  })[];
  category: string;
  channelAudiences: ("customer-facing" | "mixed")[];
  coverage: {
     evidence: {
        label: string;
        url: string;
     }[];
     notes: string[];
     scope: "provider-api-subset";
  };
  credentialRequirements: {
     description: string;
     id: string;
     label: string;
     metadata: {
        minimumAccess: string[];
        projectScoped: boolean;
        scopeModel: string;
     };
     required: true;
  }[];
  directions: "bidirectional"[];
  id: string;
  limitations: string[];
  maintainers: {
     name: string;
     type: "official";
  }[];
  metadata: {
     channelCoverage: {
        ephemeralSessionIssuance: string;
        outboundCalling: string;
        realtimeAudio: string;
        realtimeToolCalls: string;
        realtimeTranscript: string;
        telephony: string;
        transcriptionOnlySessions: string;
     };
     implementation: {
        adapterCoverage: string[];
        rawClientEscapeHatch: boolean;
        sdkPackage: string;
        sdkPackages: string[];
        strategy: string;
        verifiedAt: string;
        verifiedVersion: string;
     };
     integrationEntryPoints: {
        manifest: string;
        runtime: string;
     };
     integrationName: string;
     integrationPackageName: string;
     rawClient: {
        coverage: string;
        export: string;
        option: string;
     };
  };
  name: string;
  operations: (
     | {
     alias: string;
     capability: string;
     exposesSensitiveData: true;
     externallyVisible?: never;
     providerObject: string;
     providerOperation: string;
     requiresCredential: true;
     sideEffect?: never;
   }
     | {
     alias: string;
     capability: string;
     exposesSensitiveData?: never;
     externallyVisible: true;
     providerObject: string;
     providerOperation: string;
     requiresCredential: true;
     sideEffect: true;
  })[];
  packageName: string;
  privacyNotes: string[];
  provider: string;
  trustLevel: "official";
}, unknown, {
  voice.session.start: (input, context) => Promise<OpenAIRealtimeSessionStartResult>;
  voice.speak: (input, context) => Promise<{
     event: RealtimeClientEvent;
     speechId?: string;
  }>;
  voice.turn.finalize: (input, context) => Promise<OpenAI.Realtime.RealtimeClientEvent>;
}>;

Functions¶

createOpenAIRealtimeSocket()¶

function createOpenAIRealtimeSocket(input): Promise<OpenAIRealtimeSocket>;

Parameters¶

Parameter	Type
`input`	`OpenAIRealtimeFactoryInput`

Returns¶

Promise\<OpenAIRealtimeSocket>

createOpenAIVoiceClient()¶

function createOpenAIVoiceClient(options?): OpenAIVoiceClient;

Parameters¶

Parameter	Type
`options?`	`OpenAIVoiceClientOptions`

Returns¶

OpenAIVoiceClient

createOpenAIVoiceOperationHandlers()¶

function createOpenAIVoiceOperationHandlers(options?): {
  voice.session.start: (input, context) => Promise<OpenAIRealtimeSessionStartResult>;
  voice.speak: (input, context) => Promise<{
     event: RealtimeClientEvent;
     speechId?: string;
  }>;
  voice.turn.finalize: (input, context) => Promise<RealtimeClientEvent>;
};

Parameters¶

Parameter	Type
`options?`	{ `voiceClient?`: `OpenAIVoiceClient`; }
`options.voiceClient?`	`OpenAIVoiceClient`

Returns¶

{
  voice.session.start: (input, context) => Promise<OpenAIRealtimeSessionStartResult>;
  voice.speak: (input, context) => Promise<{
     event: RealtimeClientEvent;
     speechId?: string;
  }>;
  voice.turn.finalize: (input, context) => Promise<RealtimeClientEvent>;
}

Name	Type
`voice.session.start()`	(`input`, `context`) => `Promise`\<`OpenAIRealtimeSessionStartResult`>
`voice.speak()`	(`input`, `context`) => `Promise`\<{ `event`: `RealtimeClientEvent`; `speechId?`: `string`; }>
`voice.turn.finalize()`	(`input`, `context`) => `Promise`\<`RealtimeClientEvent`>

createOpenAIVoiceProvider()¶

function createOpenAIVoiceProvider(options?): VoiceProvider;

Parameters¶

Parameter	Type
`options?`	`OpenAIVoiceProviderOptions`

Returns¶

VoiceProvider

References¶