> This page is for Audio Decisions. > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://dev.hume.ai/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://dev.hume.ai/_mcp/server. # Use cases **Each card is an example question to send the Audio Decisions API.** Pick an industry or search the cards, then open a card to copy its request in cURL, Python or TypeScript, and adapt the wording and options to your recordings. #### Language spoken Which language is spoken? List the languages you expect as options, such as English, Japanese, Arabic, French and Russian. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "language_spoken": { "type": "choice", "instructions": "Which language is spoken?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "language_spoken": Question_Choice( instructions="Which language is spoken?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { language_spoken: { type: "choice", instructions: "Which language is spoken?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speaking rate How fast does the speaker talk? Use levels from very slow to very fast. The answer is not a count of words per minute. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "speaking_rate": { "type": "score", "instructions": "How fast does the speaker talk?", "criteria": ["Very slow", "Slow", "Moderate", "Fast", "Very fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "speaking_rate": Question_Score( instructions="How fast does the speaker talk?", criteria=["Very slow", "Slow", "Moderate", "Fast", "Very fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { speaking_rate: { type: "score", instructions: "How fast does the speaker talk?", criteria: ["Very slow", "Slow", "Moderate", "Fast", "Very fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filler words Does the speaker say a filler such as "uh" or "um"? The answer does not say why the speaker hesitates. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filler_words": { "type": "noul", "instructions": "Does the speaker say a filler such as \"uh\" or \"um\"?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filler_words": Question_Noul( instructions="Does the speaker say a filler such as \"uh\" or \"um\"?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filler_words: { type: "noul", instructions: "Does the speaker say a filler such as \"uh\" or \"um\"?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Accent Which accent does the speaker have? List the accents you expect as options, such as Mainstream US English and South African English. An accent is not proof of nationality or first language. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "accent": { "type": "choice", "instructions": "Which accent does the speaker have?", "criteria": [ { "name": "Mainstream US English" }, { "name": "South African English" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "accent": Question_Choice( instructions="Which accent does the speaker have?", criteria=[ Criterion(name="Mainstream US English"), Criterion(name="South African English"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { accent: { type: "choice", instructions: "Which accent does the speaker have?", criteria: [ { name: "Mainstream US English" }, { name: "South African English" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Synthetic speech Is this speech artificially generated? Ask how natural the speech sounds as a separate question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "synthetic_speech": { "type": "noul", "instructions": "Is this speech artificially generated?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "synthetic_speech": Question_Noul( instructions="Is this speech artificially generated?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { synthetic_speech: { type: "noul", instructions: "Is this speech artificially generated?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Expressed emotion Which emotion does the speaker's voice convey? List the emotions as options, such as sad, happy, fearful and disgusted. The answer is the emotion expressed, not what the speaker feels. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "expressed_emotion": { "type": "choice", "instructions": "Which emotion does the speaker'\''s voice convey?", "criteria": [ { "name": "Sad" }, { "name": "Happy" }, { "name": "Fearful" }, { "name": "Disgusted" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "expressed_emotion": Question_Choice( instructions="Which emotion does the speaker's voice convey?", criteria=[ Criterion(name="Sad"), Criterion(name="Happy"), Criterion(name="Fearful"), Criterion(name="Disgusted"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { expressed_emotion: { type: "choice", instructions: "Which emotion does the speaker's voice convey?", criteria: [ { name: "Sad" }, { name: "Happy" }, { name: "Fearful" }, { name: "Disgusted" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasized word Which word carries the most stress? Put the sentence in `context`, such as "Technology has changed how we view art today.", and list the candidate words as options. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Sentence: Technology has changed how we view art today.", "questions": { "emphasized_word": { "type": "choice", "instructions": "Which word carries the most stress?", "criteria": [ { "name": "Technology" }, { "name": "changed" }, { "name": "view" }, { "name": "art" }, { "name": "today" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Sentence: Technology has changed how we view art today.", questions={ "emphasized_word": Question_Choice( instructions="Which word carries the most stress?", criteria=[ Criterion(name="Technology"), Criterion(name="changed"), Criterion(name="view"), Criterion(name="art"), Criterion(name="today"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Sentence: Technology has changed how we view art today.", questions: { emphasized_word: { type: "choice", instructions: "Which word carries the most stress?", criteria: [ { name: "Technology" }, { name: "changed" }, { name: "view" }, { name: "art" }, { name: "today" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background noise Is there noise behind the speaker? Ask what kind of noise it is as a separate question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_noise": { "type": "noul", "instructions": "Is there noise behind the speaker?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_noise": Question_Noul( instructions="Is there noise behind the speaker?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_noise: { type: "noul", instructions: "Is there noise behind the speaker?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Kind of background noise Which kind of sound is most prominent under the voice? List the kinds you expect as options, such as hiss, hum, other people talking and music. The answer names the sound, not its cause. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "kind_of_background_noise": { "type": "choice", "instructions": "Which kind of sound is most prominent under the voice?", "criteria": [ { "name": "Hiss" }, { "name": "Hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "kind_of_background_noise": Question_Choice( instructions="Which kind of sound is most prominent under the voice?", criteria=[ Criterion(name="Hiss"), Criterion(name="Hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { kind_of_background_noise: { type: "choice", instructions: "Which kind of sound is most prominent under the voice?", criteria: [ { name: "Hiss" }, { name: "Hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise intrusiveness How intrusive is the background noise? Use levels from not noticeable to very intrusive. The answer is a listener's judgment, not a decibel level. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_intrusiveness": { "type": "score", "instructions": "How intrusive is the background noise?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_intrusiveness": Question_Score( instructions="How intrusive is the background noise?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_intrusiveness: { type: "score", instructions: "How intrusive is the background noise?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Sound quality How would most listeners rate the sound quality of this speech? Use levels from bad to excellent, and compare answers only between recordings of the same kind, such as phone calls with phone calls. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "sound_quality": { "type": "score", "instructions": "How would most listeners rate the sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "sound_quality": Question_Score( instructions="How would most listeners rate the sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { sound_quality: { type: "score", instructions: "How would most listeners rate the sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter Does anyone laugh? Ask about each other vocal sound, such as a cough, as a separate question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter": { "type": "noul", "instructions": "Does anyone laugh?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter": Question_Noul( instructions="Does anyone laugh?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter: { type: "noul", instructions: "Does anyone laugh?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Kind of vocal sound Which kind of vocal sound is most prominent? List the sounds you expect as options, such as a cough, a breath, a cry and a burp. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "kind_of_vocal_sound": { "type": "choice", "instructions": "Which kind of vocal sound is most prominent?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Cry" }, { "name": "Burp" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "kind_of_vocal_sound": Question_Choice( instructions="Which kind of vocal sound is most prominent?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Cry"), Criterion(name="Burp"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { kind_of_vocal_sound: { type: "choice", instructions: "Which kind of vocal sound is most prominent?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Cry" }, { name: "Burp" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### When laughter occurs When does someone laugh? The answer lists the time spans where laughter may occur, with times measured from the start of the file. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the start of the supplied recording.", "questions": { "when_laughter_occurs": { "type": "span", "instructions": "When does someone laugh?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the start of the supplied recording.", questions={ "when_laughter_occurs": Question_Span( instructions="When does someone laugh?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the start of the supplied recording.", questions: { when_laughter_occurs: { type: "span", instructions: "When does someone laugh?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A named sound Can running water be heard? Name the sound in the question. The answer says whether the sound is heard, not what caused it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_named_sound": { "type": "noul", "instructions": "Can running water be heard?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_named_sound": Question_Noul( instructions="Can running water be heard?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_named_sound: { type: "noul", instructions: "Can running water be heard?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Which listed sound Which of the listed sounds is most prominent? List the sounds that could occur in your recordings as options, such as a dog barking, a vacuum cleaner and an alarm bell. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "which_listed_sound": { "type": "choice", "instructions": "Which of the listed sounds is most prominent?", "criteria": [ { "name": "Dog barking" }, { "name": "Vacuum cleaner" }, { "name": "Alarm bell" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "which_listed_sound": Question_Choice( instructions="Which of the listed sounds is most prominent?", criteria=[ Criterion(name="Dog barking"), Criterion(name="Vacuum cleaner"), Criterion(name="Alarm bell"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { which_listed_sound: { type: "choice", instructions: "Which of the listed sounds is most prominent?", criteria: [ { name: "Dog barking" }, { name: "Vacuum cleaner" }, { name: "Alarm bell" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### When a sound occurs When is a car horn heard? Name the sound in full in the question. Times are measured from the start of the file you send. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "when_a_sound_occurs": { "type": "span", "instructions": "When is a car horn heard?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "when_a_sound_occurs": Question_Span( instructions="When is a car horn heard?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { when_a_sound_occurs: { type: "span", instructions: "When is a car horn heard?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlapping speech Do two people speak at the same time? Send the excerpt you want checked. Overlap is not always an interruption. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlapping_speech": { "type": "noul", "instructions": "Do two people speak at the same time?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlapping_speech": Question_Noul( instructions="Do two people speak at the same time?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlapping_speech: { type: "noul", instructions: "Do two people speak at the same time?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Interruption or acknowledgment Does the second speaker take over the turn, or does the first speaker carry on? Send one excerpt in which someone speaks during another person's turn. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "interruption_or_acknowledgment": { "type": "choice", "instructions": "Does the second speaker take over the turn, or does the first speaker carry on?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "interruption_or_acknowledgment": Question_Choice( instructions="Does the second speaker take over the turn, or does the first speaker carry on?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { interruption_or_acknowledgment: { type: "choice", instructions: "Does the second speaker take over the turn, or does the first speaker carry on?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pause within a turn Is there a pause of half a second or more within one person's turn? The answer does not say why the speaker paused. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "pause_within_a_turn": { "type": "noul", "instructions": "Is there a pause of half a second or more within one person'\''s turn?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "pause_within_a_turn": Question_Noul( instructions="Is there a pause of half a second or more within one person's turn?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { pause_within_a_turn: { type: "noul", instructions: "Is there a pause of half a second or more within one person's turn?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness How natural does the speech sound? Use levels from bad to excellent, and rank voices or model versions by the answer. Natural-sounding speech is not proof that a person spoke it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness": { "type": "score", "instructions": "How natural does the speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness": Question_Score( instructions="How natural does the speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness: { type: "score", instructions: "How natural does the speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Relevance of a reply How well does the assistant's reply address what the user said? Put the earlier conversation in `context`. The answer judges relevance, not whether the reply is correct. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Earlier conversation:\nUser: Find me a quiet café near the station.\nAssistant: There are two nearby. Do you want one with outdoor seating?", "questions": { "relevance_of_a_reply": { "type": "score", "instructions": "How well does the assistant'\''s reply address what the user said?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Earlier conversation:\nUser: Find me a quiet café near the station.\nAssistant: There are two nearby. Do you want one with outdoor seating?", questions={ "relevance_of_a_reply": Question_Score( instructions="How well does the assistant's reply address what the user said?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Earlier conversation:\nUser: Find me a quiet café near the station.\nAssistant: There are two nearby. Do you want one with outdoor seating?", questions: { relevance_of_a_reply: { type: "score", instructions: "How well does the assistant's reply address what the user said?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Intelligibility How many of the 10 Mandarin characters in the sentence can a listener understand? Use five count ranges as the levels: 0 to 2, 3 to 4, 5 to 6, 7 to 8 and 9 to 10. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "intelligibility": { "type": "score", "instructions": "How many of the 10 Mandarin characters in the sentence can a listener understand?", "criteria": ["0 to 2", "3 to 4", "5 to 6", "7 to 8", "9 to 10"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "intelligibility": Question_Score( instructions="How many of the 10 Mandarin characters in the sentence can a listener understand?", criteria=["0 to 2", "3 to 4", "5 to 6", "7 to 8", "9 to 10"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { intelligibility: { type: "score", instructions: "How many of the 10 Mandarin characters in the sentence can a listener understand?", criteria: ["0 to 2", "3 to 4", "5 to 6", "7 to 8", "9 to 10"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Routing a request What is the user asking the assistant to do? List the requests your assistant handles as options, such as checking the weather, adding a calendar event and playing music. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "routing_a_request": { "type": "choice", "instructions": "What is the user asking the assistant to do?", "criteria": [ { "name": "Check the weather" }, { "name": "Add a calendar event" }, { "name": "Play music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "routing_a_request": Question_Choice( instructions="What is the user asking the assistant to do?", criteria=[ Criterion(name="Check the weather"), Criterion(name="Add a calendar event"), Criterion(name="Play music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { routing_a_request: { type: "choice", instructions: "What is the user asking the assistant to do?", criteria: [ { name: "Check the weather" }, { name: "Add a calendar event" }, { name: "Play music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Order of two sounds Which do you hear first, the cough or the laugh? Name both sounds in the question and give an option for each, so audio where they overlap or one is missing can go to "None of these or unclear". #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "order_of_two_sounds": { "type": "choice", "instructions": "Which do you hear first, the cough or the laugh?", "criteria": [ { "name": "Cough first" }, { "name": "Laugh first" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "order_of_two_sounds": Question_Choice( instructions="Which do you hear first, the cough or the laugh?", criteria=[ Criterion(name="Cough first"), Criterion(name="Laugh first"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { order_of_two_sounds: { type: "choice", instructions: "Which do you hear first, the cough or the laugh?", criteria: [ { name: "Cough first" }, { name: "Laugh first" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pause after a word After which word does the speaker pause? Put the transcript in `context`, and list the candidate words as options. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Transcript: Well, honestly, no, I haven'\''t decided yet.", "questions": { "pause_after_a_word": { "type": "choice", "instructions": "After which word does the speaker pause?", "criteria": [ { "name": "Well" }, { "name": "honestly" }, { "name": "no" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Transcript: Well, honestly, no, I haven't decided yet.", questions={ "pause_after_a_word": Question_Choice( instructions="After which word does the speaker pause?", criteria=[ Criterion(name="Well"), Criterion(name="honestly"), Criterion(name="no"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Transcript: Well, honestly, no, I haven't decided yet.", questions: { pause_after_a_word: { type: "choice", instructions: "After which word does the speaker pause?", criteria: [ { name: "Well" }, { name: "honestly" }, { name: "no" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### When a word is spoken When is the word "night" spoken? The answer lists the time spans where the word may be spoken, with the start and end of each. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "when_a_word_is_spoken": { "type": "span", "instructions": "When is the word \"night\" spoken?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "when_a_word_is_spoken": Question_Span( instructions="When is the word \"night\" spoken?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { when_a_word_is_spoken: { type: "span", instructions: "When is the word \"night\" spoken?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### When a topic comes up When is trend watching discussed? Ask it of the whole recording, and take the earliest span returned as the point the topic first comes up. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "when_a_topic_comes_up": { "type": "span", "instructions": "When is trend watching discussed?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "when_a_topic_comes_up": Question_Span( instructions="When is trend watching discussed?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { when_a_topic_comes_up: { type: "span", instructions: "When is trend watching discussed?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Perceived gender presentation of a designed voice Does this voice sound male, female, or neither? Describe how listeners are likely to perceive a designed voice's gender presentation, using the tested choices. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "perceived_gender_presentation_of_a_designed": { "type": "choice", "instructions": "Does this voice sound male, female, or neither?", "criteria": [ { "name": "Male" }, { "name": "Female" }, { "name": "Neither" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "perceived_gender_presentation_of_a_designed": Question_Choice( instructions="Does this voice sound male, female, or neither?", criteria=[ Criterion(name="Male"), Criterion(name="Female"), Criterion(name="Neither"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { perceived_gender_presentation_of_a_designed: { type: "choice", instructions: "Does this voice sound male, female, or neither?", criteria: [ { name: "Male" }, { name: "Female" }, { name: "Neither" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion-word incongruence Does the speaker's vocal tone fit both the words and the situation described? Whether the vocal tone fits the words and the situation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "A customer says, \"My order is late and I'\''m frustrated.\" The clip is the assistant saying, \"I'\''m sorry about the delay; I'\''ll check it now.\" Judge the audible delivery against those words and that situation, without inferring sincerity or private feelings.", "questions": { "emotion_word_incongruence": { "type": "choice", "instructions": "Does the speaker'\''s vocal tone fit both the words and the situation described?", "criteria": [ { "name": "Fits both" }, { "name": "Conflicts with the words" }, { "name": "Does not fit the situation" }, { "name": "Fits neither" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="A customer says, \"My order is late and I'm frustrated.\" The clip is the assistant saying, \"I'm sorry about the delay; I'll check it now.\" Judge the audible delivery against those words and that situation, without inferring sincerity or private feelings.", questions={ "emotion_word_incongruence": Question_Choice( instructions="Does the speaker's vocal tone fit both the words and the situation described?", criteria=[ Criterion(name="Fits both"), Criterion(name="Conflicts with the words"), Criterion(name="Does not fit the situation"), Criterion(name="Fits neither"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "A customer says, \"My order is late and I'm frustrated.\" The clip is the assistant saying, \"I'm sorry about the delay; I'll check it now.\" Judge the audible delivery against those words and that situation, without inferring sincerity or private feelings.", questions: { emotion_word_incongruence: { type: "choice", instructions: "Does the speaker's vocal tone fit both the words and the situation described?", criteria: [ { name: "Fits both" }, { name: "Conflicts with the words" }, { name: "Does not fit the situation" }, { name: "Fits neither" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background music Is music audible in the background of this recording? Whether music is audible in the environment. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_music": { "type": "noul", "instructions": "Is music audible in the background of this recording?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_music": Question_Noul( instructions="Is music audible in the background of this recording?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_music: { type: "noul", instructions: "Is music audible in the background of this recording?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Number of speakers How many distinct speakers are audible in this recording? Count the distinct speakers in the selected audio. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count distinct voices, not the number of turns.", "questions": { "number_of_speakers": { "type": "choice", "instructions": "How many distinct speakers are audible in this recording?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count distinct voices, not the number of turns.", questions={ "number_of_speakers": Question_Choice( instructions="How many distinct speakers are audible in this recording?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count distinct voices, not the number of turns.", questions: { number_of_speakers: { type: "choice", instructions: "How many distinct speakers are audible in this recording?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Did the response answer the question? Did the agent give the requested refund arrival time? Whether the reply supplies the information the person asked for. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Customer: \"When will my refund arrive?\" Judge only what the reply provides: approval alone is not an arrival time. Yes = arrival time provided; Partially = some but incomplete arrival-time information; No = requested time not provided; Unclear = insufficient audio or context.", "questions": { "did_the_response_answer_the_question": { "type": "choice", "instructions": "Did the agent give the requested refund arrival time?", "criteria": [ { "name": "Yes" }, { "name": "Partially" }, { "name": "No" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Customer: \"When will my refund arrive?\" Judge only what the reply provides: approval alone is not an arrival time. Yes = arrival time provided; Partially = some but incomplete arrival-time information; No = requested time not provided; Unclear = insufficient audio or context.", questions={ "did_the_response_answer_the_question": Question_Choice( instructions="Did the agent give the requested refund arrival time?", criteria=[ Criterion(name="Yes"), Criterion(name="Partially"), Criterion(name="No"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Customer: \"When will my refund arrive?\" Judge only what the reply provides: approval alone is not an arrival time. Yes = arrival time provided; Partially = some but incomplete arrival-time information; No = requested time not provided; Unclear = insufficient audio or context.", questions: { did_the_response_answer_the_question: { type: "choice", instructions: "Did the agent give the requested refund arrival time?", criteria: [ { name: "Yes" }, { name: "Partially" }, { name: "No" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Meeting engagement Is the group noticeably more involved here than in calm, matter-of-fact discussion? A selected window's apparent involvement compared with calm discussion. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "This is a clip from a research group'\''s meeting (headset microphones mixed together).", "questions": { "meeting_engagement": { "type": "noul", "instructions": "Is the group noticeably more involved here than in calm, matter-of-fact discussion?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="This is a clip from a research group's meeting (headset microphones mixed together).", questions={ "meeting_engagement": Question_Noul( instructions="Is the group noticeably more involved here than in calm, matter-of-fact discussion?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "This is a clip from a research group's meeting (headset microphones mixed together).", questions: { meeting_engagement: { type: "noul", instructions: "Is the group noticeably more involved here than in calm, matter-of-fact discussion?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Prioritize low-quality recordings for review How would most listeners rate the technical sound quality of this speech? Rank speech clips for a listening check before deciding which belong in training or evaluation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "prioritize_low_quality_recordings_for_review": { "type": "score", "instructions": "How would most listeners rate the technical sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "prioritize_low_quality_recordings_for_review": Question_Score( instructions="How would most listeners rate the technical sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { prioritize_low_quality_recordings_for_review: { type: "score", instructions: "How would most listeners rate the technical sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Separate overlapping speech for transcription review Do two speakers talk at the same time in this excerpt? Route clips with simultaneous speech to a dedicated annotation or evaluation slice. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "separate_overlapping_speech_for_transcription": { "type": "noul", "instructions": "Do two speakers talk at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "separate_overlapping_speech_for_transcription": Question_Noul( instructions="Do two speakers talk at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { separate_overlapping_speech_for_transcription: { type: "noul", instructions: "Do two speakers talk at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Mine vocal-burst examples for training and evaluation Is laughter audible in this excerpt? Find candidate clips containing a chosen non-speech vocalization for annotation and dataset sampling. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "mine_vocal_burst_examples_for_training": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "mine_vocal_burst_examples_for_training": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { mine_vocal_burst_examples_for_training: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Label expressed emotion for a speech dataset Which listed emotion does the voice convey? Propose vocal-expression labels that annotators can verify and compare with existing labels. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "label_expressed_emotion_for_a_speech_dataset": { "type": "choice", "instructions": "Which listed emotion does the voice convey?", "criteria": [ { "name": "Angry" }, { "name": "Disgusted" }, { "name": "Fearful" }, { "name": "Happiness" }, { "name": "Sadness" }, { "name": "Surprised" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "label_expressed_emotion_for_a_speech_dataset": Question_Choice( instructions="Which listed emotion does the voice convey?", criteria=[ Criterion(name="Angry"), Criterion(name="Disgusted"), Criterion(name="Fearful"), Criterion(name="Happiness"), Criterion(name="Sadness"), Criterion(name="Surprised"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { label_expressed_emotion_for_a_speech_dataset: { type: "choice", instructions: "Which listed emotion does the voice convey?", criteria: [ { name: "Angry" }, { name: "Disgusted" }, { name: "Fearful" }, { name: "Happiness" }, { name: "Sadness" }, { name: "Surprised" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Compare naturalness across generated-speech runs How natural does this speech sound? Rank generated samples for listening review when comparing voice models or checkpoints. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "compare_naturalness_across_generated_speech_runs": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "compare_naturalness_across_generated_speech_runs": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { compare_naturalness_across_generated_speech_runs: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check generated speech against its script Was the supplied sentence read correctly and clearly? Find generated samples that need a transcript or listening check before evaluation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The script for this generated utterance is: \"Save your work before closing the window.\" Check the supplied audio against that sentence.", "questions": { "check_generated_speech_against_its_script": { "type": "noul", "instructions": "Was the supplied sentence read correctly and clearly?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="The script for this generated utterance is: \"Save your work before closing the window.\" Check the supplied audio against that sentence.", questions={ "check_generated_speech_against_its_script": Question_Noul( instructions="Was the supplied sentence read correctly and clearly?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The script for this generated utterance is: \"Save your work before closing the window.\" Check the supplied audio against that sentence.", questions: { check_generated_speech_against_its_script: { type: "noul", instructions: "Was the supplied sentence read correctly and clearly?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check word emphasis in controlled speech Which supplied word carries the strongest emphasis? Compare generated or performed emphasis with the word assigned in a prosody experiment. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The spoken sentence is \"Send the replacement today.\"", "questions": { "check_word_emphasis_in_controlled_speech": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Send" }, { "name": "The" }, { "name": "Replacement" }, { "name": "Today" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The spoken sentence is \"Send the replacement today.\"", questions={ "check_word_emphasis_in_controlled_speech": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Send"), Criterion(name="The"), Criterion(name="Replacement"), Criterion(name="Today"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The spoken sentence is \"Send the replacement today.\"", questions: { check_word_emphasis_in_controlled_speech: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Send" }, { name: "The" }, { name: "Replacement" }, { name: "Today" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find examples of filled pauses Are filled pauses such as "uh" or "um" audible in this excerpt? Collect clips containing "uh" or "um" for a disfluency annotation queue. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "find_examples_of_filled_pauses": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "find_examples_of_filled_pauses": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { find_examples_of_filled_pauses: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check the speaker-count label on a clip How many distinct speakers are audible in this clip? Find clips whose existing speaker-count label may be wrong, for listening review before a speaker-separation study. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count audible speaking voices within this clip only; people who are present but silent do not count.", "questions": { "check_the_speaker_count_label_on_a_clip": { "type": "choice", "instructions": "How many distinct speakers are audible in this clip?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count audible speaking voices within this clip only; people who are present but silent do not count.", questions={ "check_the_speaker_count_label_on_a_clip": Question_Choice( instructions="How many distinct speakers are audible in this clip?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count audible speaking voices within this clip only; people who are present but silent do not count.", questions: { check_the_speaker_count_label_on_a_clip: { type: "choice", instructions: "How many distinct speakers are audible in this clip?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check dialogue-act labels in a call corpus Which conversational move does this utterance make? Flag utterances whose existing dialogue-act label may be wrong before the labels are used for training. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_dialogue_act_labels_in_a_call_corpus": { "type": "choice", "instructions": "Which conversational move does this utterance make?", "criteria": [ { "name": "Opening the call or introducing themselves" }, { "name": "Giving instructions" }, { "name": "Disagreeing or saying no" }, { "name": "Agreeing or saying yes" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_dialogue_act_labels_in_a_call_corpus": Question_Choice( instructions="Which conversational move does this utterance make?", criteria=[ Criterion(name="Opening the call or introducing themselves"), Criterion(name="Giving instructions"), Criterion(name="Disagreeing or saying no"), Criterion(name="Agreeing or saying yes"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_dialogue_act_labels_in_a_call_corpus: { type: "choice", instructions: "Which conversational move does this utterance make?", criteria: [ { name: "Opening the call or introducing themselves" }, { name: "Giving instructions" }, { name: "Disagreeing or saying no" }, { name: "Agreeing or saying yes" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check whether a voice-agent reply answers the question How directly does the agent's reply address the question "How do I reset my password?" Queue off-topic responses for error analysis in a voice-agent evaluation set. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The user asks \"How do I reset my password?\" The supplied audio contains the agent'\''s reply. Judge relevance to that question, not factual correctness or successful execution.", "questions": { "check_whether_a_voice_agent_reply_answers": { "type": "score", "instructions": "How directly does the agent'\''s reply address the question \"How do I reset my password?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The user asks \"How do I reset my password?\" The supplied audio contains the agent's reply. Judge relevance to that question, not factual correctness or successful execution.", questions={ "check_whether_a_voice_agent_reply_answers": Question_Score( instructions="How directly does the agent's reply address the question \"How do I reset my password?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The user asks \"How do I reset my password?\" The supplied audio contains the agent's reply. Judge relevance to that question, not factual correctness or successful execution.", questions: { check_whether_a_voice_agent_reply_answers: { type: "score", instructions: "How directly does the agent's reply address the question \"How do I reset my password?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check voice continuity in generated samples Does the replacement line sound like the same voice as the surrounding speech? Queue possible voice changes within a generated utterance for a listening review. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "A replacement sentence is joined between two surrounding sentences. The replacement begins with \"Your order arrives tomorrow.\" Compare the voice before, during and after that sentence.", "questions": { "check_voice_continuity_in_generated_samples": { "type": "noul", "instructions": "Does the replacement line sound like the same voice as the surrounding speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="A replacement sentence is joined between two surrounding sentences. The replacement begins with \"Your order arrives tomorrow.\" Compare the voice before, during and after that sentence.", questions={ "check_voice_continuity_in_generated_samples": Question_Noul( instructions="Does the replacement line sound like the same voice as the surrounding speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "A replacement sentence is joined between two surrounding sentences. The replacement begins with \"Your order arrives tomorrow.\" Compare the voice before, during and after that sentence.", questions: { check_voice_continuity_in_generated_samples: { type: "noul", instructions: "Does the replacement line sound like the same voice as the surrounding speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check delivery against a speaking direction How strongly would listeners agree that the vocal delivery fits the supplied direction for this line? Compare how well generated takes follow a controlled expressive direction. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The line is \"Thanks for waiting; I can help you now.\" The speaking direction is calm and reassuring, without sounding rushed. Rate the audible delivery against that direction.", "questions": { "check_delivery_against_a_speaking_direction": { "type": "score", "instructions": "How strongly would listeners agree that the vocal delivery fits the supplied direction for this line?", "criteria": ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The line is \"Thanks for waiting; I can help you now.\" The speaking direction is calm and reassuring, without sounding rushed. Rate the audible delivery against that direction.", questions={ "check_delivery_against_a_speaking_direction": Question_Score( instructions="How strongly would listeners agree that the vocal delivery fits the supplied direction for this line?", criteria=["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The line is \"Thanks for waiting; I can help you now.\" The speaking direction is calm and reassuring, without sounding rushed. Rate the audible delivery against that direction.", questions: { check_delivery_against_a_speaking_direction: { type: "score", instructions: "How strongly would listeners agree that the vocal delivery fits the supplied direction for this line?", criteria: ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Separate backchannels from floor-taking Does the second speaker take over the turn, or briefly acknowledge while the first continues? Review selected interjections before using them as dialogue-behavior labels. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "separate_backchannels_from_floor_taking": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment without taking the floor" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "separate_backchannels_from_floor_taking": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment without taking the floor"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { separate_backchannels_from_floor_taking: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment without taking the floor" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Sort recordings by spoken language Which listed language is spoken in this clip? Route a bounded multilingual collection to the appropriate annotation queue. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The collection is documented to contain single-language clips in English, Japanese, Arabic, French or Russian.", "questions": { "sort_recordings_by_spoken_language": { "type": "choice", "instructions": "Which listed language is spoken in this clip?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The collection is documented to contain single-language clips in English, Japanese, Arabic, French or Russian.", questions={ "sort_recordings_by_spoken_language": Question_Choice( instructions="Which listed language is spoken in this clip?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The collection is documented to contain single-language clips in English, Japanese, Arabic, French or Russian.", questions: { sort_recordings_by_spoken_language: { type: "choice", instructions: "Which listed language is spoken in this clip?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find overlapping speech within a recording Find the intervals where two people speak at the same time. Suggest candidate intervals for annotators to mark overlapping speech more precisely. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Return candidate intervals relative to this audio.", "questions": { "find_overlapping_speech_within_a_recording": { "type": "span", "instructions": "Find the intervals where two people speak at the same time." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Return candidate intervals relative to this audio.", questions={ "find_overlapping_speech_within_a_recording": Question_Span( instructions="Find the intervals where two people speak at the same time.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Return candidate intervals relative to this audio.", questions: { find_overlapping_speech_within_a_recording: { type: "span", instructions: "Find the intervals where two people speak at the same time.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a topic passage for a research corpus Find the parts of this interview discussing how the participant uses voice assistants. Retrieve candidate excerpts about a specified research topic for human coding. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "find_a_topic_passage_for_a_research_corpus": { "type": "span", "instructions": "Find the parts of this interview discussing how the participant uses voice assistants." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "find_a_topic_passage_for_a_research_corpus": Question_Span( instructions="Find the parts of this interview discussing how the participant uses voice assistants.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { find_a_topic_passage_for_a_research_corpus: { type: "span", instructions: "Find the parts of this interview discussing how the participant uses voice assistants.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Create speaking-rate evaluation slices How fast does the speaker talk in this clip? Rank clips by coarse speaking rate and set slow, moderate and fast slice thresholds for balanced testing. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "create_speaking_rate_evaluation_slices": { "type": "score", "instructions": "How fast does the speaker talk in this clip?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "create_speaking_rate_evaluation_slices": Question_Score( instructions="How fast does the speaker talk in this clip?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { create_speaking_rate_evaluation_slices: { type: "score", instructions: "How fast does the speaker talk in this clip?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a spoken target for alignment review Find where "Friday" is spoken in this recording. Locate candidate instances of a target word to inspect a speech-alignment dataset. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Return candidate intervals relative to this clip.", "questions": { "find_a_spoken_target_for_alignment_review": { "type": "span", "instructions": "Find where \"Friday\" is spoken in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Return candidate intervals relative to this clip.", questions={ "find_a_spoken_target_for_alignment_review": Question_Span( instructions="Find where \"Friday\" is spoken in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Return candidate intervals relative to this clip.", questions: { find_a_spoken_target_for_alignment_review: { type: "span", instructions: "Find where \"Friday\" is spoken in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Label a sound from a known class inventory Which listed sound can be heard? Propose an event class for a bounded sound-event corpus. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "label_a_sound_from_a_known_class_inventory": { "type": "choice", "instructions": "Which listed sound can be heard?", "criteria": [ { "name": "Speech" }, { "name": "Dog" }, { "name": "Vacuum cleaner" }, { "name": "Alarm bell ringing" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "label_a_sound_from_a_known_class_inventory": Question_Choice( instructions="Which listed sound can be heard?", criteria=[ Criterion(name="Speech"), Criterion(name="Dog"), Criterion(name="Vacuum cleaner"), Criterion(name="Alarm bell ringing"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { label_a_sound_from_a_known_class_inventory: { type: "choice", instructions: "Which listed sound can be heard?", criteria: [ { name: "Speech" }, { name: "Dog" }, { name: "Vacuum cleaner" }, { name: "Alarm bell ringing" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check word order in a speech-generation test Is "Friday" spoken before or after "Monday"? Compare a generated utterance with a test that deliberately varies the order of two words. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_word_order_in_a_speech_generation_test": { "type": "choice", "instructions": "Is \"Friday\" spoken before or after \"Monday\"?", "criteria": [ { "name": "Friday before Monday" }, { "name": "Friday after Monday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_word_order_in_a_speech_generation_test": Question_Choice( instructions="Is \"Friday\" spoken before or after \"Monday\"?", criteria=[ Criterion(name="Friday before Monday"), Criterion(name="Friday after Monday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_word_order_in_a_speech_generation_test: { type: "choice", instructions: "Is \"Friday\" spoken before or after \"Monday\"?", criteria: [ { name: "Friday before Monday" }, { name: "Friday after Monday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find laughter to cut annotation clips Find the laughter in this recording. Suggest laughter intervals that a data pipeline can export with surrounding context for review. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Timestamps are relative to this recording.", "questions": { "find_laughter_to_cut_annotation_clips": { "type": "span", "instructions": "Find the laughter in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Timestamps are relative to this recording.", questions={ "find_laughter_to_cut_annotation_clips": Question_Span( instructions="Find the laughter in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Timestamps are relative to this recording.", questions: { find_laughter_to_cut_annotation_clips: { type: "span", instructions: "Find the laughter in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Build background-noise evaluation slices Which listed background sound is audible underneath the voice? Group clips by a specified audible noise type to compare model performance under different conditions. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "build_background_noise_evaluation_slices": { "type": "choice", "instructions": "Which listed background sound is audible underneath the voice?", "criteria": [ { "name": "Hiss" }, { "name": "Hum" }, { "name": "Background chatter" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "build_background_noise_evaluation_slices": Question_Choice( instructions="Which listed background sound is audible underneath the voice?", criteria=[ Criterion(name="Hiss"), Criterion(name="Hum"), Criterion(name="Background chatter"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { build_background_noise_evaluation_slices: { type: "choice", instructions: "Which listed background sound is audible underneath the voice?", criteria: [ { name: "Hiss" }, { name: "Hum" }, { name: "Background chatter" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Measure background interference How intrusive is the background sound? Keep separate evaluation slices for unobtrusive and intrusive background sound. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "measure_background_interference": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "measure_background_interference": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { measure_background_interference: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check a requested value in spoken-command data Which delivery day does the speaker ask for? Compare a spoken command's requested value with the existing annotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_a_requested_value_in_spoken_command_data": { "type": "choice", "instructions": "Which delivery day does the speaker ask for?", "criteria": [ { "name": "Monday" }, { "name": "Tuesday" }, { "name": "Thursday" }, { "name": "Friday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_a_requested_value_in_spoken_command_data": Question_Choice( instructions="Which delivery day does the speaker ask for?", criteria=[ Criterion(name="Monday"), Criterion(name="Tuesday"), Criterion(name="Thursday"), Criterion(name="Friday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_a_requested_value_in_spoken_command_data: { type: "choice", instructions: "Which delivery day does the speaker ask for?", criteria: [ { name: "Monday" }, { name: "Tuesday" }, { name: "Thursday" }, { name: "Friday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a voice-over take Which word carries the strongest emphasis? Put the line in `context`, such as "The offer ends on Friday.", and list its words as options. Compare the answer with the word the brief calls for. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Line: The offer ends on Friday.", "questions": { "emphasis_in_a_voice_over_take": { "type": "choice", "instructions": "Which word carries the strongest emphasis?", "criteria": [ { "name": "offer" }, { "name": "ends" }, { "name": "on" }, { "name": "Friday" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Line: The offer ends on Friday.", questions={ "emphasis_in_a_voice_over_take": Question_Choice( instructions="Which word carries the strongest emphasis?", criteria=[ Criterion(name="offer"), Criterion(name="ends"), Criterion(name="on"), Criterion(name="Friday"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Line: The offer ends on Friday.", questions: { emphasis_in_a_voice_over_take: { type: "choice", instructions: "Which word carries the strongest emphasis?", criteria: [ { name: "offer" }, { name: "ends" }, { name: "on" }, { name: "Friday" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Voice match after a pickup Does the replacement line sound like the same voice as the surrounding ad? Send the original excerpt, the replacement line and the original again in one file. Use levels from definitely different to definitely the same. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The listening file plays an original voice-over excerpt, the replacement line, then the original excerpt again. Check whether the voice sounds consistent across the edit, where recording conditions or audio processing may differ.", "questions": { "voice_match_after_a_pickup": { "type": "score", "instructions": "Does the replacement line sound like the same voice as the surrounding ad?", "criteria": ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The listening file plays an original voice-over excerpt, the replacement line, then the original excerpt again. Check whether the voice sounds consistent across the edit, where recording conditions or audio processing may differ.", questions={ "voice_match_after_a_pickup": Question_Score( instructions="Does the replacement line sound like the same voice as the surrounding ad?", criteria=["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The listening file plays an original voice-over excerpt, the replacement line, then the original excerpt again. Check whether the voice sounds consistent across the edit, where recording conditions or audio processing may differ.", questions: { voice_match_after_a_pickup: { type: "score", instructions: "Does the replacement line sound like the same voice as the surrounding ad?", criteria: ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Recording problem Which of these recording problems is most audible? List the problems as options, such as background noise, muffled sound, dropouts and clipping. Use the answer to decide what to inspect during cleanup. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "recording_problem": { "type": "choice", "instructions": "Which of these recording problems is most audible?", "criteria": [ { "name": "Background noise" }, { "name": "Muffled or tinny sound" }, { "name": "Dropouts or interruptions" }, { "name": "Clipping" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "recording_problem": Question_Choice( instructions="Which of these recording problems is most audible?", criteria=[ Criterion(name="Background noise"), Criterion(name="Muffled or tinny sound"), Criterion(name="Dropouts or interruptions"), Criterion(name="Clipping"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { recording_problem: { type: "choice", instructions: "Which of these recording problems is most audible?", criteria: [ { name: "Background noise" }, { name: "Muffled or tinny sound" }, { name: "Dropouts or interruptions" }, { name: "Clipping" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in an asset library Is laughter audible in this clip? Ask it of each clip in your asset library, and listen to the matches to choose one. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_an_asset_library": { "type": "noul", "instructions": "Is laughter audible in this clip?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_an_asset_library": Question_Noul( instructions="Is laughter audible in this clip?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_an_asset_library: { type: "noul", instructions: "Is laughter audible in this clip?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Discount in an ad Which listed discount is spoken in the excerpt? List the discounts across your ad versions as options, such as 10, 15 and 20 percent. The answer is what the audio says, not whether the offer is still valid. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "discount_in_an_ad": { "type": "choice", "instructions": "Which listed discount is spoken in the excerpt?", "criteria": [ { "name": "10 percent" }, { "name": "15 percent" }, { "name": "20 percent" }, { "name": "25 percent" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "discount_in_an_ad": Question_Choice( instructions="Which listed discount is spoken in the excerpt?", criteria=[ Criterion(name="10 percent"), Criterion(name="15 percent"), Criterion(name="20 percent"), Criterion(name="25 percent"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { discount_in_an_ad: { type: "choice", instructions: "Which listed discount is spoken in the excerpt?", criteria: [ { name: "10 percent" }, { name: "15 percent" }, { name: "20 percent" }, { name: "25 percent" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of a generated ad read How natural does this speech sound? Compare how natural the generated speech sounds before choosing a delivery. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_a_generated_ad_read": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_a_generated_ad_read": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_a_generated_ad_read: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A pause inside the offer line Is there a quiet pause of half a second or more within the sentence "The offer is available through Friday"? Check whether an unexpected quiet gap interrupts the flow of a recorded sentence. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_pause_inside_the_offer_line": { "type": "noul", "instructions": "Is there a quiet pause of half a second or more within the sentence \"The offer is available through Friday\"?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_pause_inside_the_offer_line": Question_Noul( instructions="Is there a quiet pause of half a second or more within the sentence \"The offer is available through Friday\"?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_pause_inside_the_offer_line: { type: "noul", instructions: "Is there a quiet pause of half a second or more within the sentence \"The offer is available through Friday\"?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background intrusion in a creator-recorded demonstration How intrusive is the background sound? Describe distracting background sound before deciding whether to request a cleaner recording. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_intrusion_in_a_creator_recorded": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_intrusion_in_a_creator_recorded": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_intrusion_in_a_creator_recorded: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A laugh cue in a recorded spot Is laughter audible in this excerpt? Check for an audible production cue. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_laugh_cue_in_a_recorded_spot": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_laugh_cue_in_a_recorded_spot": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_laugh_cue_in_a_recorded_spot: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a spoken brand name in an ad excerpt Find where the word "Acme" is spoken in this ad excerpt. Give an editor a candidate interval to replay. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the start of the excerpt, not the original full recording.", "questions": { "find_a_spoken_brand_name_in_an_ad_excerpt": { "type": "span", "instructions": "Find where the word \"Acme\" is spoken in this ad excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the start of the excerpt, not the original full recording.", questions={ "find_a_spoken_brand_name_in_an_ad_excerpt": Question_Span( instructions="Find where the word \"Acme\" is spoken in this ad excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the start of the excerpt, not the original full recording.", questions: { find_a_spoken_brand_name_in_an_ad_excerpt: { type: "span", instructions: "Find where the word \"Acme\" is spoken in this ad excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Agreement or objection in a testimonial interview Does the customer's reply to "Was the product easy to set up?" explicitly agree, explicitly disagree, or give a mixed answer? Avoid editing a spoken disagreement into apparent agreement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt includes an interviewer asking \"Was the product easy to set up?\" and the customer'\''s reply. Classify only what the reply explicitly says; mixed or qualified answers remain mixed rather than becoming a positive endorsement.", "questions": { "agreement_or_objection_in_a_testimonial": { "type": "choice", "instructions": "Does the customer'\''s reply to \"Was the product easy to set up?\" explicitly agree, explicitly disagree, or give a mixed answer?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Mixed or qualified" }, { "name": "Neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt includes an interviewer asking \"Was the product easy to set up?\" and the customer's reply. Classify only what the reply explicitly says; mixed or qualified answers remain mixed rather than becoming a positive endorsement.", questions={ "agreement_or_objection_in_a_testimonial": Question_Choice( instructions="Does the customer's reply to \"Was the product easy to set up?\" explicitly agree, explicitly disagree, or give a mixed answer?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Mixed or qualified"), Criterion(name="Neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt includes an interviewer asking \"Was the product easy to set up?\" and the customer's reply. Classify only what the reply explicitly says; mixed or qualified answers remain mixed rather than becoming a positive endorsement.", questions: { agreement_or_objection_in_a_testimonial: { type: "choice", instructions: "Does the customer's reply to \"Was the product easy to set up?\" explicitly agree, explicitly disagree, or give a mixed answer?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Mixed or qualified" }, { name: "Neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An offer line under another voice Do two voices speak at the same time in this excerpt? Flag a candidate take that needs listening or a mix adjustment. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_offer_line_under_another_voice": { "type": "noul", "instructions": "Do two voices speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_offer_line_under_another_voice": Question_Noul( instructions="Do two voices speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_offer_line_under_another_voice: { type: "noul", instructions: "Do two voices speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion conveyed by a testimonial excerpt Which emotion is expressed by the voice in this excerpt? Describe the vocal expression without claiming to know the customer's feelings. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_conveyed_by_a_testimonial_excerpt": { "type": "choice", "instructions": "Which emotion is expressed by the voice in this excerpt?", "criteria": [ { "name": "Happy" }, { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_conveyed_by_a_testimonial_excerpt": Question_Choice( instructions="Which emotion is expressed by the voice in this excerpt?", criteria=[ Criterion(name="Happy"), Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_conveyed_by_a_testimonial_excerpt: { type: "choice", instructions: "Which emotion is expressed by the voice in this excerpt?", criteria: [ { name: "Happy" }, { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Comedic delivery in a generated spot How much do you agree that the generated voice delivers this line as a light, self-deprecating joke? Compare a generated performance with an explicit creative brief. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The line is \"Our plants have a better social life than I do.\" The brief calls for a light, self-deprecating joke rather than a serious complaint.", "questions": { "comedic_delivery_in_a_generated_spot": { "type": "score", "instructions": "How much do you agree that the generated voice delivers this line as a light, self-deprecating joke?", "criteria": ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The line is \"Our plants have a better social life than I do.\" The brief calls for a light, self-deprecating joke rather than a serious complaint.", questions={ "comedic_delivery_in_a_generated_spot": Question_Score( instructions="How much do you agree that the generated voice delivers this line as a light, self-deprecating joke?", criteria=["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The line is \"Our plants have a better social life than I do.\" The brief calls for a light, self-deprecating joke rather than a serious complaint.", questions: { comedic_delivery_in_a_generated_spot: { type: "score", instructions: "How much do you agree that the generated voice delivers this line as a light, self-deprecating joke?", criteria: ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check speaking-rate changes between ad lines From the first sentence to the second, does the voice speed up, slow down, or keep the same speed? Check a planned rate transition in the supplied take. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_speaking_rate_changes_between_ad_lines": { "type": "choice", "instructions": "From the first sentence to the second, does the voice speed up, slow down, or keep the same speed?", "criteria": [ { "name": "Speeds up" }, { "name": "Slows down" }, { "name": "Keeps the same speed" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_speaking_rate_changes_between_ad_lines": Question_Choice( instructions="From the first sentence to the second, does the voice speed up, slow down, or keep the same speed?", criteria=[ Criterion(name="Speeds up"), Criterion(name="Slows down"), Criterion(name="Keeps the same speed"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_speaking_rate_changes_between_ad_lines: { type: "choice", instructions: "From the first sentence to the second, does the voice speed up, slow down, or keep the same speed?", criteria: [ { name: "Speeds up" }, { name: "Slows down" }, { name: "Keeps the same speed" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pace against a voiceover brief Is the speaking rate slow, moderate or fast? Give concrete delivery feedback on a recording the campaign produces. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "pace_against_a_voiceover_brief": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "pace_against_a_voiceover_brief": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { pace_against_a_voiceover_brief: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses in a testimonial recording Are filled pauses such as "uh" or "um" audible in this excerpt? Keep the words and audible hesitations distinguishable when preparing a verbatim testimonial quote. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_in_a_testimonial_recording": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_in_a_testimonial_recording": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_in_a_testimonial_recording: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An accent specified in the voice brief Which listed accent does the voice sound closest to? Check a concrete delivery attribute against a supplied recording brief. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_accent_specified_in_the_voice_brief": { "type": "choice", "instructions": "Which listed accent does the voice sound closest to?", "criteria": [ { "name": "Mainstream US English" }, { "name": "South African English" }, { "name": "Neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_accent_specified_in_the_voice_brief": Question_Choice( instructions="Which listed accent does the voice sound closest to?", criteria=[ Criterion(name="Mainstream US English"), Criterion(name="South African English"), Criterion(name="Neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_accent_specified_in_the_voice_brief: { type: "choice", instructions: "Which listed accent does the voice sound closest to?", criteria: [ { name: "Mainstream US English" }, { name: "South African English" }, { name: "Neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding the laugh for a dialogue edit Find the laughter in this dialogue excerpt. Locate laughter for replay before choosing a dialogue cut. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the start of the excerpt.", "questions": { "finding_the_laugh_for_a_dialogue_edit": { "type": "span", "instructions": "Find the laughter in this dialogue excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the start of the excerpt.", questions={ "finding_the_laugh_for_a_dialogue_edit": Question_Span( instructions="Find the laughter in this dialogue excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the start of the excerpt.", questions: { finding_the_laugh_for_a_dialogue_edit: { type: "span", instructions: "Find the laughter in this dialogue excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### What the call to action says Does the spoken closing line ask the listener to act, state information, or make a commitment? Organize an existing audio archive by the explicit function of its closing lines. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "what_the_call_to_action_says": { "type": "choice", "instructions": "Does the spoken closing line ask the listener to act, state information, or make a commitment?", "criteria": [ { "name": "Asks the listener to act" }, { "name": "States information" }, { "name": "Makes a commitment" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "what_the_call_to_action_says": Question_Choice( instructions="Does the spoken closing line ask the listener to act, state information, or make a commitment?", criteria=[ Criterion(name="Asks the listener to act"), Criterion(name="States information"), Criterion(name="Makes a commitment"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { what_the_call_to_action_says: { type: "choice", instructions: "Does the spoken closing line ask the listener to act, state information, or make a commitment?", criteria: [ { name: "Asks the listener to act" }, { name: "States information" }, { name: "Makes a commitment" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speech audibility in a finished mix How much of the speech in this excerpt can a listener understand? Identify a passage where the spoken words may be difficult to make out in the mix. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "speech_audibility_in_a_finished_mix": { "type": "score", "instructions": "How much of the speech in this excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "speech_audibility_in_a_finished_mix": Question_Score( instructions="How much of the speech in this excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { speech_audibility_in_a_finished_mix: { type: "score", instructions: "How much of the speech in this excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music already present in a voiceover Is music audible beneath the speech? Avoid an accidental double music layer. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_already_present_in_a_voiceover": { "type": "noul", "instructions": "Is music audible beneath the speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_already_present_in_a_voiceover": Question_Noul( instructions="Is music audible beneath the speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_already_present_in_a_voiceover: { type: "noul", instructions: "Is music audible beneath the speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Caller's emotion Which emotion does the caller's voice convey? List emotions such as sad, angry and happy, and add "Neutral" and "None of these or unclear". The answer is how the caller sounds, not whether they will cancel. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "callers_emotion": { "type": "choice", "instructions": "Which emotion does the caller'\''s voice convey?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "callers_emotion": Question_Choice( instructions="Which emotion does the caller's voice convey?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { callers_emotion: { type: "choice", instructions: "Which emotion does the caller's voice convey?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or takeover Does the agent take over the turn, or does the caller carry on? Send the moment the agent speaks during the caller's explanation, with the speech just before and after. Say who is who in `context`. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "A support call. The agent answers the call, and the caller explains a billing problem.", "questions": { "acknowledgment_or_takeover": { "type": "choice", "instructions": "Does the agent take over the turn, or does the caller carry on?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the caller continues" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="A support call. The agent answers the call, and the caller explains a billing problem.", questions={ "acknowledgment_or_takeover": Question_Choice( instructions="Does the agent take over the turn, or does the caller carry on?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the caller continues"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "A support call. The agent answers the call, and the caller explains a billing problem.", questions: { acknowledgment_or_takeover: { type: "choice", instructions: "Does the agent take over the turn, or does the caller carry on?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the caller continues" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Dropouts on a call Does the audio cut out or skip? Send the audio as the listener received it, not a local microphone recording. The answer says whether audio drops out, not why. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "dropouts_on_a_call": { "type": "noul", "instructions": "Does the audio cut out or skip?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "dropouts_on_a_call": Question_Noul( instructions="Does the audio cut out or skip?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { dropouts_on_a_call: { type: "noul", instructions: "Does the audio cut out or skip?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Routing a caller Which listed request is the caller making? List the requests your line handles as options, such as cancel an order and return an item, and add "None of these or unclear". Send that answer to a person. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "routing_a_caller": { "type": "choice", "instructions": "Which listed request is the caller making?", "criteria": [ { "name": "Cancel an order" }, { "name": "Ask about delivery" }, { "name": "Return an item" }, { "name": "Change the delivery address" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "routing_a_caller": Question_Choice( instructions="Which listed request is the caller making?", criteria=[ Criterion(name="Cancel an order"), Criterion(name="Ask about delivery"), Criterion(name="Return an item"), Criterion(name="Change the delivery address"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { routing_a_caller: { type: "choice", instructions: "Which listed request is the caller making?", criteria: [ { name: "Cancel an order" }, { name: "Ask about delivery" }, { name: "Return an item" }, { name: "Change the delivery address" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Agent's reply on topic Does the reply address what the caller actually asked? Send the caller's question with the agent's full reply. The answer judges relevance, not whether the policy is right or the request was completed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Assess relevance to \"How do I return an item?\", separately from whether the policy is correct or the return was completed.", "questions": { "agents_reply_on_topic": { "type": "score", "instructions": "Does the reply address what the caller actually asked?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Assess relevance to \"How do I return an item?\", separately from whether the policy is correct or the return was completed.", questions={ "agents_reply_on_topic": Question_Score( instructions="Does the reply address what the caller actually asked?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Assess relevance to \"How do I return an item?\", separately from whether the policy is correct or the return was completed.", questions: { agents_reply_on_topic: { type: "score", instructions: "Does the reply address what the caller actually asked?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language of an unassigned voicemail Which listed language is spoken in this voicemail? Suggest a language queue for a person to confirm before returning the call. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "language_of_an_unassigned_voicemail": { "type": "choice", "instructions": "Which listed language is spoken in this voicemail?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "Unclear or another language" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "language_of_an_unassigned_voicemail": Question_Choice( instructions="Which listed language is spoken in this voicemail?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="Unclear or another language"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { language_of_an_unassigned_voicemail: { type: "choice", instructions: "Which listed language is spoken in this voicemail?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "Unclear or another language" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A vocal event in an unclear transcript note Which listed vocal sound best matches the non-speech sound in the selected passage? Replace a generic non-speech note with a candidate audible-event label. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_vocal_event_in_an_unclear_transcript_note": { "type": "choice", "instructions": "Which listed vocal sound best matches the non-speech sound in the selected passage?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Cry" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_vocal_event_in_an_unclear_transcript_note": Question_Choice( instructions="Which listed vocal sound best matches the non-speech sound in the selected passage?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Cry"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_vocal_event_in_an_unclear_transcript_note: { type: "choice", instructions: "Which listed vocal sound best matches the non-speech sound in the selected passage?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Cry" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reviewing pauses within a caller's turn Does the caller pause for at least half a second and then continue speaking? Identify a temporary pause within the caller's turn. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "reviewing_pauses_within_a_callers_turn": { "type": "noul", "instructions": "Does the caller pause for at least half a second and then continue speaking?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "reviewing_pauses_within_a_callers_turn": Question_Noul( instructions="Does the caller pause for at least half a second and then continue speaking?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { reviewing_pauses_within_a_callers_turn: { type: "noul", instructions: "Does the caller pause for at least half a second and then continue speaking?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of a voice assistant's service reply How natural does this speech sound? Review how a generated reply sounds in an actual customer exchange. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_a_voice_assistants_service_reply": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_a_voice_assistants_service_reply": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_a_voice_assistants_service_reply: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a disputed service request Which supplied word carries the emphasis? Locate the emphasized word before interpreting what the customer meant. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The customer says, \"I requested a refund.\" Listen to that recorded sentence and identify the stressed word rather than assuming intent from emphasis.", "questions": { "emphasis_in_a_disputed_service_request": { "type": "choice", "instructions": "Which supplied word carries the emphasis?", "criteria": [ { "name": "I" }, { "name": "Requested" }, { "name": "A" }, { "name": "Refund" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The customer says, \"I requested a refund.\" Listen to that recorded sentence and identify the stressed word rather than assuming intent from emphasis.", questions={ "emphasis_in_a_disputed_service_request": Question_Choice( instructions="Which supplied word carries the emphasis?", criteria=[ Criterion(name="I"), Criterion(name="Requested"), Criterion(name="A"), Criterion(name="Refund"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The customer says, \"I requested a refund.\" Listen to that recorded sentence and identify the stressed word rather than assuming intent from emphasis.", questions: { emphasis_in_a_disputed_service_request: { type: "choice", instructions: "Which supplied word carries the emphasis?", criteria: [ { name: "I" }, { name: "Requested" }, { name: "A" }, { name: "Refund" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a refund question received an answer Did the reply give the requested refund arrival time? Check for the specific information requested rather than a merely related reply. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Customer: \"When will my refund arrive?\" Judge whether the agent'\''s reply supplies an arrival time; approval alone is not a date.", "questions": { "whether_a_refund_question_received_an_answer": { "type": "choice", "instructions": "Did the reply give the requested refund arrival time?", "criteria": [ { "name": "Yes" }, { "name": "Partly" }, { "name": "No" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Customer: \"When will my refund arrive?\" Judge whether the agent's reply supplies an arrival time; approval alone is not a date.", questions={ "whether_a_refund_question_received_an_answer": Question_Choice( instructions="Did the reply give the requested refund arrival time?", criteria=[ Criterion(name="Yes"), Criterion(name="Partly"), Criterion(name="No"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Customer: \"When will my refund arrive?\" Judge whether the agent's reply supplies an arrival time; approval alone is not a date.", questions: { whether_a_refund_question_received_an_answer: { type: "choice", instructions: "Did the reply give the requested refund arrival time?", criteria: [ { name: "Yes" }, { name: "Partly" }, { name: "No" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Hold music continuing over speech Is music audible underneath the agent's speech? Check whether the support attachment captures the reported mixing problem. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "hold_music_continuing_over_speech": { "type": "noul", "instructions": "Is music audible underneath the agent'\''s speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "hold_music_continuing_over_speech": Question_Noul( instructions="Is music audible underneath the agent's speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { hold_music_continuing_over_speech: { type: "noul", instructions: "Is music audible underneath the agent's speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### More than one caller on a support line How many distinct voices are audible in this excerpt? Describe how many voices can be heard before asking who is participating. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "more_than_one_caller_on_a_support_line": { "type": "choice", "instructions": "How many distinct voices are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "more_than_one_caller_on_a_support_line": Question_Choice( instructions="How many distinct voices are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { more_than_one_caller_on_a_support_line: { type: "choice", instructions: "How many distinct voices are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlapping speech around an unclear instruction Do two speakers talk at the same time in this excerpt? Check whether competing voices coincide with the part the customer missed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlapping_speech_around_an_unclear_instruction": { "type": "noul", "instructions": "Do two speakers talk at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlapping_speech_around_an_unclear_instruction": Question_Noul( instructions="Do two speakers talk at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlapping_speech_around_an_unclear_instruction: { type: "noul", instructions: "Do two speakers talk at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### What the customer's reply explicitly does How does the customer respond to the agent's instruction "Please email us a photo of your receipt"? Distinguish explicit agreement or disagreement from a question, instruction or unclear reply. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains the agent saying \"Please email us a photo of your receipt\" and the customer'\''s reply. Classify that reply only; do not infer consent, completed action or agreement from tone.", "questions": { "what_the_customers_reply_explicitly_does": { "type": "choice", "instructions": "How does the customer respond to the agent'\''s instruction \"Please email us a photo of your receipt\"?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Asks a question or gives a different instruction" }, { "name": "Mixed, something else or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains the agent saying \"Please email us a photo of your receipt\" and the customer's reply. Classify that reply only; do not infer consent, completed action or agreement from tone.", questions={ "what_the_customers_reply_explicitly_does": Question_Choice( instructions="How does the customer respond to the agent's instruction \"Please email us a photo of your receipt\"?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Asks a question or gives a different instruction"), Criterion(name="Mixed, something else or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains the agent saying \"Please email us a photo of your receipt\" and the customer's reply. Classify that reply only; do not infer consent, completed action or agreement from tone.", questions: { what_the_customers_reply_explicitly_does: { type: "choice", instructions: "How does the customer respond to the agent's instruction \"Please email us a photo of your receipt\"?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Asks a question or gives a different instruction" }, { name: "Mixed, something else or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### First tool for an explicit support request Which supplied tool should the assistant select first? Illustrate a tool-selection decision without executing it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Supplied tools: transfer_to_agent — connect to a human; look_up_return_policy — retrieve the policy without changing an order; get_order_status — retrieve delivery status. Choose a name, not arguments or an action to execute.", "questions": { "first_tool_for_an_explicit_support_request": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "transfer_to_agent" }, { "name": "look_up_return_policy" }, { "name": "get_order_status" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Supplied tools: transfer_to_agent — connect to a human; look_up_return_policy — retrieve the policy without changing an order; get_order_status — retrieve delivery status. Choose a name, not arguments or an action to execute.", questions={ "first_tool_for_an_explicit_support_request": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="transfer_to_agent"), Criterion(name="look_up_return_policy"), Criterion(name="get_order_status"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Supplied tools: transfer_to_agent — connect to a human; look_up_return_policy — retrieve the policy without changing an order; get_order_status — retrieve delivery status. Choose a name, not arguments or an action to execute.", questions: { first_tool_for_an_explicit_support_request: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "transfer_to_agent" }, { name: "look_up_return_policy" }, { name: "get_order_status" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Rate of a spoken return instruction Is the speaking rate slow, moderate or fast? Describe the pace of an instruction a caller asked to hear again. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Describe the pace of the agent'\''s original instruction on how to return an item; do not equate the rate with whether the customer understood it.", "questions": { "rate_of_a_spoken_return_instruction": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Describe the pace of the agent's original instruction on how to return an item; do not equate the rate with whether the customer understood it.", questions={ "rate_of_a_spoken_return_instruction": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Describe the pace of the agent's original instruction on how to return an item; do not equate the rate with whether the customer understood it.", questions: { rate_of_a_spoken_return_instruction: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A nonverbal event in a call transcript Is laughter audible in this excerpt? Preserve an audible event in the transcript without interpreting it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_nonverbal_event_in_a_call_transcript": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_nonverbal_event_in_a_call_transcript": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_nonverbal_event_in_a_call_transcript: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### What is audible behind the customer Which listed sound is audible underneath the voice? Describe an interfering sound without guessing where the caller is. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "what_is_audible_behind_the_customer": { "type": "choice", "instructions": "Which listed sound is audible underneath the voice?", "criteria": [ { "name": "Hiss or static" }, { "name": "Low hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "what_is_audible_behind_the_customer": Question_Choice( instructions="Which listed sound is audible underneath the voice?", criteria=[ Criterion(name="Hiss or static"), Criterion(name="Low hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { what_is_audible_behind_the_customer: { type: "choice", instructions: "Which listed sound is audible underneath the voice?", criteria: [ { name: "Hiss or static" }, { name: "Low hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Replaying a stated delivery day Find the first occurrence of the word "Friday" in this delivery-date exchange. Jump back to the quoted date instead of relying on an unchecked service note. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the supplied one-minute excerpt.", "questions": { "replaying_a_stated_delivery_day": { "type": "span", "instructions": "Find the first occurrence of the word \"Friday\" in this delivery-date exchange." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the supplied one-minute excerpt.", questions={ "replaying_a_stated_delivery_day": Question_Span( instructions="Find the first occurrence of the word \"Friday\" in this delivery-date exchange.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the supplied one-minute excerpt.", questions: { replaying_a_stated_delivery_day: { type: "span", instructions: "Find the first occurrence of the word \"Friday\" in this delivery-date exchange.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Replaying the explanation of return conditions Find the parts of this service-call excerpt where return conditions are discussed. Find the explanation a reviewer wants to replay. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the start of the supplied excerpt.", "questions": { "replaying_the_explanation_of_return_conditions": { "type": "span", "instructions": "Find the parts of this service-call excerpt where return conditions are discussed." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the start of the supplied excerpt.", questions={ "replaying_the_explanation_of_return_conditions": Question_Span( instructions="Find the parts of this service-call excerpt where return conditions are discussed.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the start of the supplied excerpt.", questions: { replaying_the_explanation_of_return_conditions: { type: "span", instructions: "Find the parts of this service-call excerpt where return conditions are discussed.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Instructor's answer on topic Does the instructor's reply address the learner's question? Send the question with the full reply, and use levels from off-topic to directly relevant. The answer judges relevance, not whether the instructions are correct. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The audio includes the learner asking \"How do I save a draft?\" and the instructor'\''s reply. Judge relevance to that question independently of whether the software instructions are factually correct or complete.", "questions": { "instructors_answer_on_topic": { "type": "score", "instructions": "Does the instructor'\''s reply address the learner'\''s question?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The audio includes the learner asking \"How do I save a draft?\" and the instructor's reply. Judge relevance to that question independently of whether the software instructions are factually correct or complete.", questions={ "instructors_answer_on_topic": Question_Score( instructions="Does the instructor's reply address the learner's question?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The audio includes the learner asking \"How do I save a draft?\" and the instructor's reply. Judge relevance to that question independently of whether the software instructions are factually correct or complete.", questions: { instructors_answer_on_topic: { type: "score", instructions: "Does the instructor's reply address the learner's question?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pace of a walkthrough How fast does the instructor talk? Ask it of each section of a recorded walkthrough to find passages worth a closer listen. Fast speech is not always a problem. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "pace_of_a_walkthrough": { "type": "score", "instructions": "How fast does the instructor talk?", "criteria": ["Very slow", "Slow", "Moderate", "Fast", "Very fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "pace_of_a_walkthrough": Question_Score( instructions="How fast does the instructor talk?", criteria=["Very slow", "Slow", "Moderate", "Fast", "Very fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { pace_of_a_walkthrough: { type: "score", instructions: "How fast does the instructor talk?", criteria: ["Very slow", "Slow", "Moderate", "Fast", "Very fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Instruction read as scripted Is the training instruction read exactly as scripted? Put the script in `context`, such as "Save your work, close the application, then restart the computer." The answer checks the reading, not the procedure. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Script: Save your work, close the application, then restart the computer.", "questions": { "instruction_read_as_scripted": { "type": "noul", "instructions": "Is the training instruction read exactly as scripted?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="Script: Save your work, close the application, then restart the computer.", questions={ "instruction_read_as_scripted": Question_Noul( instructions="Is the training instruction read exactly as scripted?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Script: Save your work, close the application, then restart the computer.", questions: { instruction_read_as_scripted: { type: "noul", instructions: "Is the training instruction read exactly as scripted?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Tone in a customer-service practice reply How strongly would listeners agree that the delivery fits the direction "calm and matter-of-fact"? Help the learner compare an audible performance with the exercise direction. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The learner says, \"I can help you work through the next step.\" The direction is calm and matter-of-fact, not sarcastic or celebratory. Judge the recording, not how the learner actually feels.", "questions": { "tone_in_a_customer_service_practice_reply": { "type": "score", "instructions": "How strongly would listeners agree that the delivery fits the direction \"calm and matter-of-fact\"?", "criteria": ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The learner says, \"I can help you work through the next step.\" The direction is calm and matter-of-fact, not sarcastic or celebratory. Judge the recording, not how the learner actually feels.", questions={ "tone_in_a_customer_service_practice_reply": Question_Score( instructions="How strongly would listeners agree that the delivery fits the direction \"calm and matter-of-fact\"?", criteria=["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The learner says, \"I can help you work through the next step.\" The direction is calm and matter-of-fact, not sarcastic or celebratory. Judge the recording, not how the learner actually feels.", questions: { tone_in_a_customer_service_practice_reply: { type: "score", instructions: "How strongly would listeners agree that the delivery fits the direction \"calm and matter-of-fact\"?", criteria: ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find the worked example in a recorded lesson Find the section where the instructor demonstrates how to export the report. Give the learner a candidate place to replay the worked example. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the supplied audio.", "questions": { "find_the_worked_example_in_a_recorded_lesson": { "type": "span", "instructions": "Find the section where the instructor demonstrates how to export the report." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the supplied audio.", questions={ "find_the_worked_example_in_a_recorded_lesson": Question_Span( instructions="Find the section where the instructor demonstrates how to export the report.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the supplied audio.", questions: { find_the_worked_example_in_a_recorded_lesson: { type: "span", instructions: "Find the section where the instructor demonstrates how to export the report.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The conversational move in a practice reply Which conversational move does this reply make? Name the observable move for discussion during the exercise. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_conversational_move_in_a_practice_reply": { "type": "choice", "instructions": "Which conversational move does this reply make?", "criteria": [ { "name": "Opening the call or introducing themselves" }, { "name": "Giving instructions" }, { "name": "Disagreeing or saying no" }, { "name": "Agreeing or saying yes" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_conversational_move_in_a_practice_reply": Question_Choice( instructions="Which conversational move does this reply make?", criteria=[ Criterion(name="Opening the call or introducing themselves"), Criterion(name="Giving instructions"), Criterion(name="Disagreeing or saying no"), Criterion(name="Agreeing or saying yes"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_conversational_move_in_a_practice_reply: { type: "choice", instructions: "Which conversational move does this reply make?", criteria: [ { name: "Opening the call or introducing themselves" }, { name: "Giving instructions" }, { name: "Disagreeing or saying no" }, { name: "Agreeing or saying yes" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise in a submitted practice recording Is background noise audible behind the speaker? Note audible background sound in a submitted practice recording before giving feedback. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_in_a_submitted_practice_recording": { "type": "noul", "instructions": "Is background noise audible behind the speaker?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_in_a_submitted_practice_recording": Question_Noul( instructions="Is background noise audible behind the speaker?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_in_a_submitted_practice_recording: { type: "noul", instructions: "Is background noise audible behind the speaker?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Locating a named command in a lesson recording Find where the word "export" is spoken in this lesson excerpt. Give a learner a candidate place to replay a term they missed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the start of the excerpt.", "questions": { "locating_a_named_command_in_a_lesson_recording": { "type": "span", "instructions": "Find where the word \"export\" is spoken in this lesson excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the start of the excerpt.", questions={ "locating_a_named_command_in_a_lesson_recording": Question_Span( instructions="Find where the word \"export\" is spoken in this lesson excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the start of the excerpt.", questions: { locating_a_named_command_in_a_lesson_recording: { type: "span", instructions: "Find where the word \"export\" is spoken in this lesson excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Voices in a workshop recording How many distinct speaking voices are audible in this excerpt? Clarify whether an excerpt contains a single explanation or several audible speakers. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count voices in the selected excerpt; do not count silent attendees.", "questions": { "voices_in_a_workshop_recording": { "type": "choice", "instructions": "How many distinct speaking voices are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count voices in the selected excerpt; do not count silent attendees.", questions={ "voices_in_a_workshop_recording": Question_Choice( instructions="How many distinct speaking voices are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count voices in the selected excerpt; do not count silent attendees.", questions: { voices_in_a_workshop_recording: { type: "choice", instructions: "How many distinct speaking voices are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of generated course narration How natural does this speech sound? Describe the sound of a generated lesson passage independently of its content. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_generated_course_narration": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_generated_course_narration": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_generated_course_narration: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The help a learner explicitly asks for Which listed help request does the learner make? Identify a stated learning-support request without inferring ability or motivation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_help_a_learner_explicitly_asks": { "type": "choice", "instructions": "Which listed help request does the learner make?", "criteria": [ { "name": "Repeat a step" }, { "name": "Explain a term" }, { "name": "Show another example" }, { "name": "Fix an access problem" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_help_a_learner_explicitly_asks": Question_Choice( instructions="Which listed help request does the learner make?", criteria=[ Criterion(name="Repeat a step"), Criterion(name="Explain a term"), Criterion(name="Show another example"), Criterion(name="Fix an access problem"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_help_a_learner_explicitly_asks: { type: "choice", instructions: "Which listed help request does the learner make?", criteria: [ { name: "Repeat a step" }, { name: "Explain a term" }, { name: "Show another example" }, { name: "Fix an access problem" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses in a presentation rehearsal Are filled pauses such as "uh" or "um" audible in this excerpt? Give the presenter an observable feature of their own delivery. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_in_a_presentation_rehearsal": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_in_a_presentation_rehearsal": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_in_a_presentation_rehearsal: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis on the key instruction Which word in "Send the replacement today" carries the emphasis in this take? Check which word is emphasized in a customer-service practice line. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Identify the actual emphasis in the recorded take.", "questions": { "emphasis_on_the_key_instruction": { "type": "choice", "instructions": "Which word in \"Send the replacement today\" carries the emphasis in this take?", "criteria": [ { "name": "Send" }, { "name": "The" }, { "name": "Replacement" }, { "name": "Today" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Identify the actual emphasis in the recorded take.", questions={ "emphasis_on_the_key_instruction": Question_Choice( instructions="Which word in \"Send the replacement today\" carries the emphasis in this take?", criteria=[ Criterion(name="Send"), Criterion(name="The"), Criterion(name="Replacement"), Criterion(name="Today"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Identify the actual emphasis in the recorded take.", questions: { emphasis_on_the_key_instruction: { type: "choice", instructions: "Which word in \"Send the replacement today\" carries the emphasis in this take?", criteria: [ { name: "Send" }, { name: "The" }, { name: "Replacement" }, { name: "Today" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlapping voices during a workshop question Do two people speak at the same time in this excerpt? Flag an excerpt with overlapping voices so a reviewer can replay it before transcribing the learner's question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlapping_voices_during_a_workshop_question": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlapping_voices_during_a_workshop_question": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlapping_voices_during_a_workshop_question: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background interference in a remote workshop How intrusive is the background sound? Describe an audio problem that makes a recorded explanation harder to follow. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_interference_in_a_remote_workshop": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_interference_in_a_remote_workshop": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_interference_in_a_remote_workshop: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An inhalation near a proposed narration join Is the speaker audibly inhaling in this excerpt? Avoid an abrupt-sounding join without asking the model to make the final cut. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_inhalation_near_a_proposed_narration_join": { "type": "noul", "instructions": "Is the speaker audibly inhaling in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_inhalation_near_a_proposed_narration_join": Question_Noul( instructions="Is the speaker audibly inhaling in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_inhalation_near_a_proposed_narration_join: { type: "noul", instructions: "Is the speaker audibly inhaling in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a workshop transcript Is laughter audible in this excerpt? Preserve an audible event without labeling the audience's reaction. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_workshop_transcript": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_workshop_transcript": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_workshop_transcript: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit correction in a role-play debrief Does the learner explicitly agree or disagree with the proposed recap? Keep a learner's disagreement from becoming an apparent agreement in the recap. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The facilitator says, \"So you wanted to offer a refund first,\" and the learner replies. Classify the learner'\''s explicit response.", "questions": { "an_explicit_correction_in_a_role_play_debrief": { "type": "choice", "instructions": "Does the learner explicitly agree or disagree with the proposed recap?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Mixed or qualified" }, { "name": "Neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The facilitator says, \"So you wanted to offer a refund first,\" and the learner replies. Classify the learner's explicit response.", questions={ "an_explicit_correction_in_a_role_play_debrief": Question_Choice( instructions="Does the learner explicitly agree or disagree with the proposed recap?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Mixed or qualified"), Criterion(name="Neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The facilitator says, \"So you wanted to offer a refund first,\" and the learner replies. Classify the learner's explicit response.", questions: { an_explicit_correction_in_a_role_play_debrief: { type: "choice", instructions: "Does the learner explicitly agree or disagree with the proposed recap?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Mixed or qualified" }, { name: "Neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Taking over versus acknowledging in a role-play Does the interjection take over the turn, or does the first speaker carry on? Select a concrete turn-taking moment to discuss with the trainee. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "taking_over_versus_acknowledging_in_a_role_play": { "type": "choice", "instructions": "Does the interjection take over the turn, or does the first speaker carry on?", "criteria": [ { "name": "It interrupts and takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "taking_over_versus_acknowledging_in_a_role_play": Question_Choice( instructions="Does the interjection take over the turn, or does the first speaker carry on?", criteria=[ Criterion(name="It interrupts and takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { taking_over_versus_acknowledging_in_a_role_play: { type: "choice", instructions: "Does the interjection take over the turn, or does the first speaker carry on?", criteria: [ { name: "It interrupts and takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Flat or lively delivery in a course introduction Does the intonation sound monotone or expressive? Give the recording's author an observable delivery cue rather than a personality score. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "flat_or_lively_delivery_in_a_course_introduction": { "type": "choice", "instructions": "Does the intonation sound monotone or expressive?", "criteria": [ { "name": "Monotone" }, { "name": "Expressive" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "flat_or_lively_delivery_in_a_course_introduction": Question_Choice( instructions="Does the intonation sound monotone or expressive?", criteria=[ Criterion(name="Monotone"), Criterion(name="Expressive"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { flat_or_lively_delivery_in_a_course_introduction: { type: "choice", instructions: "Does the intonation sound monotone or expressive?", criteria: [ { name: "Monotone" }, { name: "Expressive" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The requested day in a practice request Which delivery day does the speaker ask for? Check whether the trainee's spoken request conveyed the day they intended. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_requested_day_in_a_practice_request": { "type": "choice", "instructions": "Which delivery day does the speaker ask for?", "criteria": [ { "name": "Monday" }, { "name": "Tuesday" }, { "name": "Thursday" }, { "name": "Friday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_requested_day_in_a_practice_request": Question_Choice( instructions="Which delivery day does the speaker ask for?", criteria=[ Criterion(name="Monday"), Criterion(name="Tuesday"), Criterion(name="Thursday"), Criterion(name="Friday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_requested_day_in_a_practice_request: { type: "choice", instructions: "Which delivery day does the speaker ask for?", criteria: [ { name: "Monday" }, { name: "Tuesday" }, { name: "Thursday" }, { name: "Friday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Decision reached Which decision is stated in this part of the meeting? List the decisions under discussion as options, and add "None of these or unclear". The answer is the decision stated, not the likely outcome. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "decision_reached": { "type": "choice", "instructions": "Which decision is stated in this part of the meeting?", "criteria": [ { "name": "Hand over on Tuesday" }, { "name": "Hand over on Thursday" }, { "name": "Keep the date undecided" }, { "name": "Cancel the handover" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "decision_reached": Question_Choice( instructions="Which decision is stated in this part of the meeting?", criteria=[ Criterion(name="Hand over on Tuesday"), Criterion(name="Hand over on Thursday"), Criterion(name="Keep the date undecided"), Criterion(name="Cancel the handover"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { decision_reached: { type: "choice", instructions: "Which decision is stated in this part of the meeting?", criteria: [ { name: "Hand over on Tuesday" }, { name: "Hand over on Thursday" }, { name: "Keep the date undecided" }, { name: "Cancel the handover" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Action item assigned Which action is explicitly assigned in this excerpt? List candidate actions as options, such as sending the checklist, and add "None of these or unclear". Confirm the owner and deadline before adding it to a task list. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "action_item_assigned": { "type": "choice", "instructions": "Which action is explicitly assigned in this excerpt?", "criteria": [ { "name": "Send the checklist" }, { "name": "Schedule a walkthrough" }, { "name": "Update the contact list" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "action_item_assigned": Question_Choice( instructions="Which action is explicitly assigned in this excerpt?", criteria=[ Criterion(name="Send the checklist"), Criterion(name="Schedule a walkthrough"), Criterion(name="Update the contact list"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { action_item_assigned: { type: "choice", instructions: "Which action is explicitly assigned in this excerpt?", criteria: [ { name: "Send the checklist" }, { name: "Schedule a walkthrough" }, { name: "Update the contact list" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reply on topic Does the reply address the question that was asked? Send a question such as "Who will own the handover checklist?" with its reply. A reply about the deadline concerns the project but not the question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge relevance to \"Who will own the handover checklist?\", not whether ownership was formally assigned. A statement about the deadline may be relevant to the project but does not necessarily address who owns the work.", "questions": { "reply_on_topic": { "type": "score", "instructions": "Does the reply address the question that was asked?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge relevance to \"Who will own the handover checklist?\", not whether ownership was formally assigned. A statement about the deadline may be relevant to the project but does not necessarily address who owns the work.", questions={ "reply_on_topic": Question_Score( instructions="Does the reply address the question that was asked?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge relevance to \"Who will own the handover checklist?\", not whether ownership was formally assigned. A statement about the deadline may be relevant to the project but does not necessarily address who owns the work.", questions: { reply_on_topic: { type: "score", instructions: "Does the reply address the question that was asked?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Remote participant's audio Does the remote participant's audio cut out or skip? Send the meeting recording of the remote participant. The answer says whether audio drops out, not how well they presented. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "remote_participants_audio": { "type": "noul", "instructions": "Does the remote participant'\''s audio cut out or skip?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "remote_participants_audio": Question_Noul( instructions="Does the remote participant's audio cut out or skip?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { remote_participants_audio: { type: "noul", instructions: "Does the remote participant's audio cut out or skip?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find the budget discussion in a recorded meeting Find the parts of the meeting where the budget is discussed. Find the relevant parts of a planning conversation to replay. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the start of the supplied audio.", "questions": { "find_the_budget_discussion_in_a_recorded_meeting": { "type": "span", "instructions": "Find the parts of the meeting where the budget is discussed." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the start of the supplied audio.", questions={ "find_the_budget_discussion_in_a_recorded_meeting": Question_Span( instructions="Find the parts of the meeting where the budget is discussed.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the start of the supplied audio.", questions: { find_the_budget_discussion_in_a_recorded_meeting: { type: "span", instructions: "Find the parts of the meeting where the budget is discussed.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Crosstalk around a proposed quotation Do people speak at the same time in this excerpt? Flag a passage that needs closer replay before attributing words. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "crosstalk_around_a_proposed_quotation": { "type": "noul", "instructions": "Do people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "crosstalk_around_a_proposed_quotation": Question_Noul( instructions="Do people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { crosstalk_around_a_proposed_quotation: { type: "noul", instructions: "Do people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit response to a proposal How does the selected reply respond to the proposal? Capture the reply without turning it into an inference about team consensus. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains a proposal and the reply immediately following it. Classify that reply only. A request for clarification is a question, not automatically disagreement; mixed or unclear responses do not establish consensus.", "questions": { "an_explicit_response_to_a_proposal": { "type": "choice", "instructions": "How does the selected reply respond to the proposal?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Asks a question" }, { "name": "Qualified, something else or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains a proposal and the reply immediately following it. Classify that reply only. A request for clarification is a question, not automatically disagreement; mixed or unclear responses do not establish consensus.", questions={ "an_explicit_response_to_a_proposal": Question_Choice( instructions="How does the selected reply respond to the proposal?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Asks a question"), Criterion(name="Qualified, something else or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains a proposal and the reply immediately following it. Classify that reply only. A request for clarification is a question, not automatically disagreement; mixed or unclear responses do not establish consensus.", questions: { an_explicit_response_to_a_proposal: { type: "choice", instructions: "How does the selected reply respond to the proposal?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Asks a question" }, { name: "Qualified, something else or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### How many voices join the discussion? How many distinct voices are audible in this excerpt? Describe an excerpt that sounds like more than a solo update. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count audible speakers in this excerpt, not silent attendees or identities.", "questions": { "how_many_voices_join_the_discussion": { "type": "choice", "instructions": "How many distinct voices are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count audible speakers in this excerpt, not silent attendees or identities.", questions={ "how_many_voices_join_the_discussion": Question_Choice( instructions="How many distinct voices are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count audible speakers in this excerpt, not silent attendees or identities.", questions: { how_many_voices_join_the_discussion: { type: "choice", instructions: "How many distinct voices are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A bilingual passage needing transcription attention Can you hear a switch between Mandarin and English? Flag mixed-language passages for the appropriate transcription pass. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_bilingual_passage_needing_transcription": { "type": "noul", "instructions": "Can you hear a switch between Mandarin and English?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_bilingual_passage_needing_transcription": Question_Noul( instructions="Can you hear a switch between Mandarin and English?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_bilingual_passage_needing_transcription: { type: "noul", instructions: "Can you hear a switch between Mandarin and English?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment versus taking the floor Does the second speaker take over the turn, or does the first speaker carry on? Distinguish a brief agreement sound from a change of speaker. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "acknowledgment_versus_taking_the_floor": { "type": "choice", "instructions": "Does the second speaker take over the turn, or does the first speaker carry on?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "acknowledgment_versus_taking_the_floor": Question_Choice( instructions="Does the second speaker take over the turn, or does the first speaker carry on?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { acknowledgment_versus_taking_the_floor: { type: "choice", instructions: "Does the second speaker take over the turn, or does the first speaker carry on?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A background event in the meeting recording Which listed sound best describes the unexpected event in this excerpt? Describe an audible interruption without identifying whose device produced it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_background_event_in_the_meeting_recording": { "type": "choice", "instructions": "Which listed sound best describes the unexpected event in this excerpt?", "criteria": [ { "name": "Speech" }, { "name": "Dog" }, { "name": "Vacuum cleaner" }, { "name": "Alarm bell ringing" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_background_event_in_the_meeting_recording": Question_Choice( instructions="Which listed sound best describes the unexpected event in this excerpt?", criteria=[ Criterion(name="Speech"), Criterion(name="Dog"), Criterion(name="Vacuum cleaner"), Criterion(name="Alarm bell ringing"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_background_event_in_the_meeting_recording: { type: "choice", instructions: "Which listed sound best describes the unexpected event in this excerpt?", criteria: [ { name: "Speech" }, { name: "Dog" }, { name: "Vacuum cleaner" }, { name: "Alarm bell ringing" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Replaying the quoted deadline Find the first occurrence of the word "Tuesday" in this meeting excerpt. Let the note's reader check the quoted date in context. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the supplied one-minute excerpt.", "questions": { "replaying_the_quoted_deadline": { "type": "span", "instructions": "Find the first occurrence of the word \"Tuesday\" in this meeting excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the supplied one-minute excerpt.", questions={ "replaying_the_quoted_deadline": Question_Span( instructions="Find the first occurrence of the word \"Tuesday\" in this meeting excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the supplied one-minute excerpt.", questions: { replaying_the_quoted_deadline: { type: "span", instructions: "Find the first occurrence of the word \"Tuesday\" in this meeting excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background interference in a remote meeting Rate the background sound in this passage, from very intrusive to not noticeable. Describe the background sound when participants say a passage was hard to hear. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_interference_in_a_remote_meeting": { "type": "score", "instructions": "Rate the background sound in this passage, from very intrusive to not noticeable.", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_interference_in_a_remote_meeting": Question_Score( instructions="Rate the background sound in this passage, from very intrusive to not noticeable.", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_interference_in_a_remote_meeting: { type: "score", instructions: "Rate the background sound in this passage, from very intrusive to not noticeable.", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language of a passage in a shared recording Which listed language is spoken in this excerpt? Choose the language needed for an appropriate transcript pass. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The supplied passage is known to use one of the five listed languages.", "questions": { "language_of_a_passage_in_a_shared_recording": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The supplied passage is known to use one of the five listed languages.", questions={ "language_of_a_passage_in_a_shared_recording": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The supplied passage is known to use one of the five listed languages.", questions: { language_of_a_passage_in_a_shared_recording: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a verbatim meeting excerpt Is laughter audible in this excerpt? Keep the transcript faithful without judging employee engagement or intent. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_verbatim_meeting_excerpt": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_verbatim_meeting_excerpt": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_verbatim_meeting_excerpt: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a spoken deadline proposal Which supplied word carries the strongest emphasis? Locate stress in the actual meeting sentence before interpreting the speaker's meaning. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "A participant says, \"We can ship Monday.\"", "questions": { "emphasis_in_a_spoken_deadline_proposal": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "We" }, { "name": "Can" }, { "name": "Ship" }, { "name": "Monday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="A participant says, \"We can ship Monday.\"", questions={ "emphasis_in_a_spoken_deadline_proposal": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="We"), Criterion(name="Can"), Criterion(name="Ship"), Criterion(name="Monday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "A participant says, \"We can ship Monday.\"", questions: { emphasis_in_a_spoken_deadline_proposal: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "We" }, { name: "Can" }, { name: "Ship" }, { name: "Monday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a meeting quotation is intelligible How much of the speech in this excerpt can a listener understand? Separate an uncertain recording from a confirmed quotation in the notes. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "whether_a_meeting_quotation_is_intelligible": { "type": "score", "instructions": "How much of the speech in this excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "whether_a_meeting_quotation_is_intelligible": Question_Score( instructions="How much of the speech in this excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { whether_a_meeting_quotation_is_intelligible: { type: "score", instructions: "How much of the speech in this excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A quiet pause before a participant continues Is there a quiet pause of half a second or more inside this person's turn? Describe an audible gap without guessing why the speaker paused. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_quiet_pause_before_a_participant_continues": { "type": "noul", "instructions": "Is there a quiet pause of half a second or more inside this person'\''s turn?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_quiet_pause_before_a_participant_continues": Question_Noul( instructions="Is there a quiet pause of half a second or more inside this person's turn?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_quiet_pause_before_a_participant_continues: { type: "noul", instructions: "Is there a quiet pause of half a second or more inside this person's turn?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion in a performed line Which listed emotion does the voice convey? List emotions such as sad, fearful and happy, and compare the answer with the direction. The answer is the performed expression, not the actor's feelings. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_in_a_performed_line": { "type": "choice", "instructions": "Which listed emotion does the voice convey?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_in_a_performed_line": Question_Choice( instructions="Which listed emotion does the voice convey?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_in_a_performed_line: { type: "choice", instructions: "Which listed emotion does the voice convey?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language of a dubbed track Which listed language is spoken in this excerpt? List the languages of your localized versions as options, and compare the answer with the track's label. Check tracks in other languages separately. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The supplied track is from the English, Japanese, Arabic, French or Russian localized versions.", "questions": { "language_of_a_dubbed_track": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The supplied track is from the English, Japanese, Arabic, French or Russian localized versions.", questions={ "language_of_a_dubbed_track": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The supplied track is from the English, Japanese, Arabic, French or Russian localized versions.", questions: { language_of_a_dubbed_track: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Dialogue audibility in the mix How much of the speech in this excerpt can a listener understand? Flag hard-to-understand dialogue for a listening check before mix revision. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "dialogue_audibility_in_the_mix": { "type": "score", "instructions": "How much of the speech in this excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "dialogue_audibility_in_the_mix": Question_Score( instructions="How much of the speech in this excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { dialogue_audibility_in_the_mix: { type: "score", instructions: "How much of the speech in this excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a spoken cue in a recording Find where the word "midnight" is spoken in this recording. Find a spoken cue to replay before aligning an edit. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "find_a_spoken_cue_in_a_recording": { "type": "span", "instructions": "Find where the word \"midnight\" is spoken in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "find_a_spoken_cue_in_a_recording": Question_Span( instructions="Find where the word \"midnight\" is spoken in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { find_a_spoken_cue_in_a_recording: { type: "span", instructions: "Find where the word \"midnight\" is spoken in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music in a dialogue-only export Is music audible behind the dialogue? Check whether a purported dialogue-only excerpt still contains audible music. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_in_a_dialogue_only_export": { "type": "noul", "instructions": "Is music audible behind the dialogue?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_in_a_dialogue_only_export": Question_Noul( instructions="Is music audible behind the dialogue?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_in_a_dialogue_only_export: { type: "noul", instructions: "Is music audible behind the dialogue?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Dialogue against scene effects How intrusive is the background sound behind the dialogue? Flag a mix passage for human listening without diagnosing a technical cause. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "dialogue_against_scene_effects": { "type": "score", "instructions": "How intrusive is the background sound behind the dialogue?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "dialogue_against_scene_effects": Question_Score( instructions="How intrusive is the background sound behind the dialogue?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { dialogue_against_scene_effects: { type: "score", instructions: "How intrusive is the background sound behind the dialogue?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check comedic delivery of a generated joke take How much do you agree that the generated voice delivers this joke in a fitting comedic way? Get a rough listener-style read on whether a generated take delivers a joke in a fitting way. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The line is \"I started a band called The Waiting List. We haven'\''t got a gig yet.\" Judge whether the audible delivery suits a joke.", "questions": { "check_comedic_delivery_of_a_generated_joke_take": { "type": "score", "instructions": "How much do you agree that the generated voice delivers this joke in a fitting comedic way?", "criteria": ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The line is \"I started a band called The Waiting List. We haven't got a gig yet.\" Judge whether the audible delivery suits a joke.", questions={ "check_comedic_delivery_of_a_generated_joke_take": Question_Score( instructions="How much do you agree that the generated voice delivers this joke in a fitting comedic way?", criteria=["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The line is \"I started a band called The Waiting List. We haven't got a gig yet.\" Judge whether the audible delivery suits a joke.", questions: { check_comedic_delivery_of_a_generated_joke_take: { type: "score", instructions: "How much do you agree that the generated voice delivers this joke in a fitting comedic way?", criteria: ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses in an improvised scene Are filled pauses such as "uh" or "um" audible? Describe an audible feature of an improvised take without treating it as a flaw. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_in_an_improvised_scene": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_in_an_improvised_scene": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_in_an_improvised_scene: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pace in a performed line How fast is the speaking rate in this line? Check a concrete direction without interpreting the actor's actual state. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "pace_in_a_performed_line": { "type": "score", "instructions": "How fast is the speaking rate in this line?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "pace_in_a_performed_line": Question_Score( instructions="How fast is the speaking rate in this line?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { pace_in_a_performed_line: { type: "score", instructions: "How fast is the speaking rate in this line?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A character taking over another character's turn Does the second speaker take over the turn, or briefly acknowledge while the first continues? Check one performed interruption against the scene's conversational staging. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_character_taking_over_another_characters_turn": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_character_taking_over_another_characters_turn": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_character_taking_over_another_characters_turn: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The type of vocal cue in a scene Which listed vocal sound is the cue in this excerpt? Describe a short non-speech cue before comparing it with the script. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_type_of_vocal_cue_in_a_scene": { "type": "choice", "instructions": "Which listed vocal sound is the cue in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Cry" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_type_of_vocal_cue_in_a_scene": Question_Choice( instructions="Which listed vocal sound is the cue in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Cry"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_type_of_vocal_cue_in_a_scene: { type: "choice", instructions: "Which listed vocal sound is the cue in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Cry" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check that a scripted laugh was recorded Is laughter audible in this excerpt? Check for a specific recorded performance cue. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_that_a_scripted_laugh_was_recorded": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_that_a_scripted_laugh_was_recorded": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_that_a_scripted_laugh_was_recorded: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The explicit request in a scene Which listed request does the character make? Keep a dialogue annotation faithful to what a character asks for. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_explicit_request_in_a_scene": { "type": "choice", "instructions": "Which listed request does the character make?", "criteria": [ { "name": "Open the door" }, { "name": "Call a taxi" }, { "name": "Keep a secret" }, { "name": "Wait outside" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_explicit_request_in_a_scene": Question_Choice( instructions="Which listed request does the character make?", criteria=[ Criterion(name="Open the door"), Criterion(name="Call a taxi"), Criterion(name="Keep a secret"), Criterion(name="Wait outside"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_explicit_request_in_a_scene: { type: "choice", instructions: "Which listed request does the character make?", criteria: [ { name: "Open the door" }, { name: "Call a taxi" }, { name: "Keep a secret" }, { name: "Wait outside" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speaking voices in a scene excerpt How many distinct speakers are audible in this excerpt? Check the audible cast size of a selected passage, not the identity of the cast. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count voices speaking in the supplied passage, including any off-screen voices, not silent performers; do not identify characters.", "questions": { "speaking_voices_in_a_scene_excerpt": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count voices speaking in the supplied passage, including any off-screen voices, not silent performers; do not identify characters.", questions={ "speaking_voices_in_a_scene_excerpt": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count voices speaking in the supplied passage, including any off-screen voices, not silent performers; do not identify characters.", questions: { speaking_voices_in_a_scene_excerpt: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Agreement or objection in a scene exchange Does the reply to "Let's leave town tonight." explicitly agree or disagree with that proposal? Check whether the dialogue contains an explicit agreement before describing the scene that way. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The scene excerpt includes one character proposing \"Let'\''s leave town tonight.\" and the other character'\''s reply. Treat a qualified or mixed reply as unresolved rather than assuming cooperation.", "questions": { "agreement_or_objection_in_a_scene_exchange": { "type": "choice", "instructions": "Does the reply to \"Let'\''s leave town tonight.\" explicitly agree or disagree with that proposal?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Mixed, neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The scene excerpt includes one character proposing \"Let's leave town tonight.\" and the other character's reply. Treat a qualified or mixed reply as unresolved rather than assuming cooperation.", questions={ "agreement_or_objection_in_a_scene_exchange": Question_Choice( instructions="Does the reply to \"Let's leave town tonight.\" explicitly agree or disagree with that proposal?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Mixed, neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The scene excerpt includes one character proposing \"Let's leave town tonight.\" and the other character's reply. Treat a qualified or mixed reply as unresolved rather than assuming cooperation.", questions: { agreement_or_objection_in_a_scene_exchange: { type: "choice", instructions: "Does the reply to \"Let's leave town tonight.\" explicitly agree or disagree with that proposal?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Mixed, neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Review naturalness of synthetic character dialogue How natural does this speech sound? Review the perceived naturalness of generated character dialogue when choosing takes. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "review_naturalness_of_synthetic_character": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "review_naturalness_of_synthetic_character": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { review_naturalness_of_synthetic_character: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The decision stated in a scene Which decision is explicitly reached in this exchange? Check a scene log against the spoken decision. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_decision_stated_in_a_scene": { "type": "choice", "instructions": "Which decision is explicitly reached in this exchange?", "criteria": [ { "name": "Meet at the station" }, { "name": "Meet at the café" }, { "name": "Meet at the bridge" }, { "name": "Do not meet again" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_decision_stated_in_a_scene": Question_Choice( instructions="Which decision is explicitly reached in this exchange?", criteria=[ Criterion(name="Meet at the station"), Criterion(name="Meet at the café"), Criterion(name="Meet at the bridge"), Criterion(name="Do not meet again"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_decision_stated_in_a_scene: { type: "choice", instructions: "Which decision is explicitly reached in this exchange?", criteria: [ { name: "Meet at the station" }, { name: "Meet at the café" }, { name: "Meet at the bridge" }, { name: "Do not meet again" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check a scripted laugh cue against the spoken line Is the laugh before or after the spoken word "finally"? Check whether a recorded laugh occurs on the specified side of a scripted word. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "check_a_scripted_laugh_cue_against_the_spoken": { "type": "choice", "instructions": "Is the laugh before or after the spoken word \"finally\"?", "criteria": [ { "name": "Before" }, { "name": "After" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "check_a_scripted_laugh_cue_against_the_spoken": Question_Choice( instructions="Is the laugh before or after the spoken word \"finally\"?", criteria=[ Criterion(name="Before"), Criterion(name="After"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { check_a_scripted_laugh_cue_against_the_spoken: { type: "choice", instructions: "Is the laugh before or after the spoken word \"finally\"?", criteria: [ { name: "Before" }, { name: "After" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Compare a dialogue take's emphasis with the script Which word in "You took my ticket." carries the strongest emphasis? Identify the performed stress to compare a take with the supplied script direction. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Identify the word actually emphasized in the supplied take.", "questions": { "compare_a_dialogue_takes_emphasis": { "type": "choice", "instructions": "Which word in \"You took my ticket.\" carries the strongest emphasis?", "criteria": [ { "name": "You" }, { "name": "Took" }, { "name": "My" }, { "name": "Ticket" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Identify the word actually emphasized in the supplied take.", questions={ "compare_a_dialogue_takes_emphasis": Question_Choice( instructions="Which word in \"You took my ticket.\" carries the strongest emphasis?", criteria=[ Criterion(name="You"), Criterion(name="Took"), Criterion(name="My"), Criterion(name="Ticket"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Identify the word actually emphasized in the supplied take.", questions: { compare_a_dialogue_takes_emphasis: { type: "choice", instructions: "Which word in \"You took my ticket.\" carries the strongest emphasis?", criteria: [ { name: "You" }, { name: "Took" }, { name: "My" }, { name: "Ticket" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A scripted simultaneous line Do the two voices speak at the same time in this closing-phrase excerpt? Check the presence of a planned conversational event. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_scripted_simultaneous_line": { "type": "noul", "instructions": "Do the two voices speak at the same time in this closing-phrase excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_scripted_simultaneous_line": Question_Noul( instructions="Do the two voices speak at the same time in this closing-phrase excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_scripted_simultaneous_line: { type: "noul", instructions: "Do the two voices speak at the same time in this closing-phrase excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check voice continuity after replacing a dialogue line On a scale from definitely different to definitely the same, how does the replacement line's voice compare with the surrounding dialogue? Check perceived voice continuity across a dialogue edit. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The listening file plays an original dialogue excerpt, the replacement line, then the original excerpt again. Compare how consistent the voice sounds across the edit.", "questions": { "check_voice_continuity_after_replacing_2": { "type": "score", "instructions": "On a scale from definitely different to definitely the same, how does the replacement line'\''s voice compare with the surrounding dialogue?", "criteria": ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The listening file plays an original dialogue excerpt, the replacement line, then the original excerpt again. Compare how consistent the voice sounds across the edit.", questions={ "check_voice_continuity_after_replacing_2": Question_Score( instructions="On a scale from definitely different to definitely the same, how does the replacement line's voice compare with the surrounding dialogue?", criteria=["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The listening file plays an original dialogue excerpt, the replacement line, then the original excerpt again. Compare how consistent the voice sounds across the edit.", questions: { check_voice_continuity_after_replacing_2: { type: "score", instructions: "On a scale from definitely different to definitely the same, how does the replacement line's voice compare with the surrounding dialogue?", criteria: ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Routing a banking request Which listed request is the caller making? List the topics your line handles as options, such as changing an address and paying a bill. The answer neither authenticates the caller nor changes the account. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "routing_a_banking_request": { "type": "choice", "instructions": "Which listed request is the caller making?", "criteria": [ { "name": "Change an address" }, { "name": "Use a card abroad" }, { "name": "Pay a bill" }, { "name": "Report a problem with the app" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "routing_a_banking_request": Question_Choice( instructions="Which listed request is the caller making?", criteria=[ Criterion(name="Change an address"), Criterion(name="Use a card abroad"), Criterion(name="Pay a bill"), Criterion(name="Report a problem with the app"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { routing_a_banking_request: { type: "choice", instructions: "Which listed request is the caller making?", criteria: [ { name: "Change an address" }, { name: "Use a card abroad" }, { name: "Pay a bill" }, { name: "Report a problem with the app" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reference number read back Is the transaction reference number read back correctly? Put the expected number in `context`, such as "four six two, nine one seven", and send the agent's readout. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Expected reference number: four six two, nine one seven", "questions": { "reference_number_read_back": { "type": "noul", "instructions": "Is the transaction reference number read back correctly?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="Expected reference number: four six two, nine one seven", questions={ "reference_number_read_back": Question_Noul( instructions="Is the transaction reference number read back correctly?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Expected reference number: four six two, nine one seven", questions: { reference_number_read_back: { type: "noul", instructions: "Is the transaction reference number read back correctly?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reply to a fee question Does the reply address what the customer asked? Send the customer's question about a fee with the full reply. The answer judges relevance, not whether the fee or the explanation is correct. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge relevance, not whether the fee is lawful, the explanation is true or a refund is owed.", "questions": { "reply_to_a_fee_question": { "type": "score", "instructions": "Does the reply address what the customer asked?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge relevance, not whether the fee is lawful, the explanation is true or a refund is owed.", questions={ "reply_to_a_fee_question": Question_Score( instructions="Does the reply address what the customer asked?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge relevance, not whether the fee is lawful, the explanation is true or a refund is owed.", questions: { reply_to_a_fee_question: { type: "score", instructions: "Does the reply address what the customer asked?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Echo on a banking call Can an echo of the speech be heard? Send the audio as the caller heard it. The answer says whether an echo is heard, not what the account information was. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "echo_on_a_banking_call": { "type": "noul", "instructions": "Can an echo of the speech be heard?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "echo_on_a_banking_call": Question_Noul( instructions="Can an echo of the speech be heard?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { echo_on_a_banking_call: { type: "noul", instructions: "Can an echo of the speech be heard?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Agreement and hesitant-sounding delivery in a bank callback How does the caller respond to the callback offer, including whether an agreement sounds hesitant? Distinguish the caller's stated response from how an agreement sounds. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "agreement_and_hesitant_sounding_delivery": { "type": "choice", "instructions": "How does the caller respond to the callback offer, including whether an agreement sounds hesitant?", "criteria": [ { "name": "Agrees, with hesitant-sounding delivery" }, { "name": "Agrees, without clear hesitant-sounding delivery" }, { "name": "Declines" }, { "name": "Asks a question" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "agreement_and_hesitant_sounding_delivery": Question_Choice( instructions="How does the caller respond to the callback offer, including whether an agreement sounds hesitant?", criteria=[ Criterion(name="Agrees, with hesitant-sounding delivery"), Criterion(name="Agrees, without clear hesitant-sounding delivery"), Criterion(name="Declines"), Criterion(name="Asks a question"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { agreement_and_hesitant_sounding_delivery: { type: "choice", instructions: "How does the caller respond to the callback offer, including whether an agreement sounds hesitant?", criteria: [ { name: "Agrees, with hesitant-sounding delivery" }, { name: "Agrees, without clear hesitant-sounding delivery" }, { name: "Declines" }, { name: "Asks a question" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a disputed-transaction account Which supplied word carries the strongest emphasis? Locate the stressed word before asking the customer to clarify its meaning. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The customer says, \"I paid that bill yesterday.\" Identify the audible stress, without deciding whether the payment actually happened.", "questions": { "emphasis_in_a_disputed_transaction_account": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "I" }, { "name": "Paid" }, { "name": "That" }, { "name": "Bill" }, { "name": "Yesterday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The customer says, \"I paid that bill yesterday.\" Identify the audible stress, without deciding whether the payment actually happened.", questions={ "emphasis_in_a_disputed_transaction_account": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="I"), Criterion(name="Paid"), Criterion(name="That"), Criterion(name="Bill"), Criterion(name="Yesterday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The customer says, \"I paid that bill yesterday.\" Identify the audible stress, without deciding whether the payment actually happened.", questions: { emphasis_in_a_disputed_transaction_account: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "I" }, { name: "Paid" }, { name: "That" }, { name: "Bill" }, { name: "Yesterday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Several voices on the customer side of a call How many distinct speakers are audible in this excerpt? Count audible voices before the person handling the call asks who is present. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "several_voices_on_the_customer_side_of_a_call": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "several_voices_on_the_customer_side_of_a_call": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { several_voices_on_the_customer_side_of_a_call: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion expressed during a service complaint Which emotion is conveyed by the voice in this excerpt? Describe vocal expression separately from the merits of the complaint. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_expressed_during_a_service_complaint": { "type": "choice", "instructions": "Which emotion is conveyed by the voice in this excerpt?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_expressed_during_a_service_complaint": Question_Choice( instructions="Which emotion is conveyed by the voice in this excerpt?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_expressed_during_a_service_complaint: { type: "choice", instructions: "Which emotion is conveyed by the voice in this excerpt?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speaking rate while explaining an account problem Is the speaking rate slow, moderate or fast? Describe the pace of the customer's spoken explanation, not their competence or emotional state. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "speaking_rate_while_explaining_an_account": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "speaking_rate_while_explaining_an_account": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { speaking_rate_while_explaining_an_account: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or taking over in a banking call Does the representative take over the turn, or briefly acknowledge while the customer continues? Describe one exchange where a customer and representative begin speaking together. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The representative is the speaker who begins speaking at the start of the excerpt.", "questions": { "acknowledgment_or_taking_over_in_a_banking_call": { "type": "choice", "instructions": "Does the representative take over the turn, or briefly acknowledge while the customer continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The representative is the speaker who begins speaking at the start of the excerpt.", questions={ "acknowledgment_or_taking_over_in_a_banking_call": Question_Choice( instructions="Does the representative take over the turn, or briefly acknowledge while the customer continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The representative is the speaker who begins speaking at the start of the excerpt.", questions: { acknowledgment_or_taking_over_in_a_banking_call: { type: "choice", instructions: "Does the representative take over the turn, or briefly acknowledge while the customer continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding the explanation of a fee Find where the explanation of the fee begins. Find the part of a call a reviewer wants to replay. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "finding_the_explanation_of_a_fee": { "type": "span", "instructions": "Find where the explanation of the fee begins." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "finding_the_explanation_of_a_fee": Question_Span( instructions="Find where the explanation of the fee begins.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { finding_the_explanation_of_a_fee: { type: "span", instructions: "Find where the explanation of the fee begins.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise in a callback voicemail How intrusive is the background sound? Flag a noisy message for closer listening before a callback request is written down. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_in_a_callback_voicemail": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_in_a_callback_voicemail": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_in_a_callback_voicemail: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlapping voices during an address explanation Do two people speak at the same time in this excerpt? Check whether simultaneous speech is present where part of the exchange was missed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlapping_voices_during_an_address_explanation": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlapping_voices_during_an_address_explanation": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlapping_voices_during_an_address_explanation: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Replaying a refund-time statement Find the first occurrence of "Friday" in this recording. Locate the date mention so its surrounding qualification can be checked. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the supplied one-minute excerpt.", "questions": { "replaying_a_refund_time_statement": { "type": "span", "instructions": "Find the first occurrence of \"Friday\" in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the supplied one-minute excerpt.", questions={ "replaying_a_refund_time_statement": Question_Span( instructions="Find the first occurrence of \"Friday\" in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the supplied one-minute excerpt.", questions: { replaying_a_refund_time_statement: { type: "span", instructions: "Find the first occurrence of \"Friday\" in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses in an explanation Are filled pauses such as "uh" or "um" audible? Describe audible hesitations without treating them as evidence about the account or caller. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_in_an_explanation": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_in_an_explanation": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_in_an_explanation: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Selecting a first service tool Which supplied tool should the assistant select first? Illustrate the next administrative function without executing an account change. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Tools: transfer_to_staff connects them to staff; explain_address_change describes the steps; get_opening_hours returns service hours. Select only a tool name.", "questions": { "selecting_a_first_service_tool": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "transfer_to_staff" }, { "name": "explain_address_change" }, { "name": "get_opening_hours" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Tools: transfer_to_staff connects them to staff; explain_address_change describes the steps; get_opening_hours returns service hours. Select only a tool name.", questions={ "selecting_a_first_service_tool": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="transfer_to_staff"), Criterion(name="explain_address_change"), Criterion(name="get_opening_hours"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Tools: transfer_to_staff connects them to staff; explain_address_change describes the steps; get_opening_hours returns service hours. Select only a tool name.", questions: { selecting_a_first_service_tool: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "transfer_to_staff" }, { name: "explain_address_change" }, { name: "get_opening_hours" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language support for a banking call Which listed language is spoken in this excerpt? Identify a likely language so the caller can be offered communication support. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The call is known to use one of the five listed languages.", "questions": { "language_support_for_a_banking_call": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The call is known to use one of the five listed languages.", questions={ "language_support_for_a_banking_call": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The call is known to use one of the five listed languages.", questions: { language_support_for_a_banking_call: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A vocal sound in a recorded customer account Which listed vocal sound is audible in this excerpt? Describe a non-word event without interpreting its cause or the customer's state. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_vocal_sound_in_a_recorded_customer_account": { "type": "choice", "instructions": "Which listed vocal sound is audible in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Other vocal sound" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_vocal_sound_in_a_recorded_customer_account": Question_Choice( instructions="Which listed vocal sound is audible in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Other vocal sound"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_vocal_sound_in_a_recorded_customer_account: { type: "choice", instructions: "Which listed vocal sound is audible in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Other vocal sound" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a customer interview quotation Is laughter audible in this excerpt? Preserve a non-word event when preparing a verbatim quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_customer_interview_quotation": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_customer_interview_quotation": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_customer_interview_quotation: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Voice command Which listed action is the player asking for? List your voice menu as options, such as open the map, show the quest log and pause the game. Handle commands outside the menu separately. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "voice_command": { "type": "choice", "instructions": "Which listed action is the player asking for?", "criteria": [ { "name": "Open the map" }, { "name": "Show the quest log" }, { "name": "Pause the game" }, { "name": "Open audio settings" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "voice_command": Question_Choice( instructions="Which listed action is the player asking for?", criteria=[ Criterion(name="Open the map"), Criterion(name="Show the quest log"), Criterion(name="Pause the game"), Criterion(name="Open audio settings"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { voice_command: { type: "choice", instructions: "Which listed action is the player asking for?", criteria: [ { name: "Open the map" }, { name: "Show the quest log" }, { name: "Pause the game" }, { name: "Open audio settings" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Teammate callout Is the teammate asking someone to act, reporting an event or offering to act? List the three as options, and add "None of these or unclear". The answer classifies what is said, not teamwork or intent. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "teammate_callout": { "type": "choice", "instructions": "Is the teammate asking someone to act, reporting an event or offering to act?", "criteria": [ { "name": "Asks someone to act" }, { "name": "Reports an event" }, { "name": "Offers to act" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "teammate_callout": Question_Choice( instructions="Is the teammate asking someone to act, reporting an event or offering to act?", criteria=[ Criterion(name="Asks someone to act"), Criterion(name="Reports an event"), Criterion(name="Offers to act"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { teammate_callout: { type: "choice", instructions: "Is the teammate asking someone to act, reporting an event or offering to act?", criteria: [ { name: "Asks someone to act" }, { name: "Reports an event" }, { name: "Offers to act" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlapping callouts Do two players speak at the same time in this excerpt? The answer says whether speech overlaps, not who was at fault. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlapping_callouts": { "type": "noul", "instructions": "Do two players speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlapping_callouts": Question_Noul( instructions="Do two players speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlapping_callouts: { type: "noul", instructions: "Do two players speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Choosing a performance take Which emotion does the actor's delivery convey in this take? Ask it of each take of a line such as "Get back! The bridge is falling!", and keep the takes that match the brief. The answer is the performed expression. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "choosing_a_performance_take": { "type": "choice", "instructions": "Which emotion does the actor'\''s delivery convey in this take?", "criteria": [ { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Sad" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "choosing_a_performance_take": Question_Choice( instructions="Which emotion does the actor's delivery convey in this take?", criteria=[ Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Sad"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { choosing_a_performance_take: { type: "choice", instructions: "Which emotion does the actor's delivery convey in this take?", criteria: [ { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Sad" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter for a game asset Is laughter audible in this clip? Search a game's sound library by asking it of every candidate clip, then audition the matches. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_for_a_game_asset": { "type": "noul", "instructions": "Is laughter audible in this clip?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_for_a_game_asset": Question_Noul( instructions="Is laughter audible in this clip?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_for_a_game_asset: { type: "noul", instructions: "Is laughter audible in this clip?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of a generated tutorial take How natural does the speech sound? Flag a draft generated line for revision before selecting the tutorial recording. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_a_generated_tutorial_take": { "type": "score", "instructions": "How natural does the speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_a_generated_tutorial_take": Question_Score( instructions="How natural does the speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_a_generated_tutorial_take: { type: "score", instructions: "How natural does the speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language in a multiplayer voice message Which listed language is spoken in this voice message? Help a player decide which language support or translation option to request. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "For this example, the voice message is known to use one of the five listed languages.", "questions": { "language_in_a_multiplayer_voice_message": { "type": "choice", "instructions": "Which listed language is spoken in this voice message?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="For this example, the voice message is known to use one of the five listed languages.", questions={ "language_in_a_multiplayer_voice_message": Question_Choice( instructions="Which listed language is spoken in this voice message?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "For this example, the voice message is known to use one of the five listed languages.", questions: { language_in_a_multiplayer_voice_message: { type: "choice", instructions: "Which listed language is spoken in this voice message?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speaking rate in a teammate's callout Is the speaking rate slow, moderate or fast? Describe how quickly a teammate speaks during a recorded exchange, without equating pace with skill or urgency. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Rate the pace of the selected voice-chat passage, separately from microphone quality, word recognition or whether the player made the right decision.", "questions": { "speaking_rate_in_a_teammates_callout": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Rate the pace of the selected voice-chat passage, separately from microphone quality, word recognition or whether the player made the right decision.", questions={ "speaking_rate_in_a_teammates_callout": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Rate the pace of the selected voice-chat passage, separately from microphone quality, word recognition or whether the player made the right decision.", questions: { speaking_rate_in_a_teammates_callout: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### How many voices are in a shared-microphone clip? How many distinct speaking voices are audible in this excerpt? Distinguish one audible speaker from several without assigning voices to player accounts. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "how_many_voices_are_in_a_shared_microphone_clip": { "type": "choice", "instructions": "How many distinct speaking voices are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "how_many_voices_are_in_a_shared_microphone_clip": Question_Choice( instructions="How many distinct speaking voices are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { how_many_voices_are_in_a_shared_microphone_clip: { type: "choice", instructions: "How many distinct speaking voices are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A deliberately flat fictional guide voice Does the intonation sound monotone or expressive? Check whether a designed voice candidate matches the character brief. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_deliberately_flat_fictional_guide_voice": { "type": "choice", "instructions": "Does the intonation sound monotone or expressive?", "criteria": [ { "name": "Monotone" }, { "name": "Expressive" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_deliberately_flat_fictional_guide_voice": Question_Choice( instructions="Does the intonation sound monotone or expressive?", criteria=[ Criterion(name="Monotone"), Criterion(name="Expressive"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_deliberately_flat_fictional_guide_voice: { type: "choice", instructions: "Does the intonation sound monotone or expressive?", criteria: [ { name: "Monotone" }, { name: "Expressive" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Selecting a companion function for a spoken request Which supplied function should the game companion select first? Distinguish a request for location information from immediately starting a match. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Available functions: find_nearest_checkpoint returns the nearest checkpoint; show_all_checkpoints lists every checkpoint without selecting the nearest; start_match begins a match; open_settings opens preferences. The question selects a function only; it does not execute it.", "questions": { "selecting_a_companion_function_for_a_spoken": { "type": "choice", "instructions": "Which supplied function should the game companion select first?", "criteria": [ { "name": "find_nearest_checkpoint" }, { "name": "show_all_checkpoints" }, { "name": "start_match" }, { "name": "open_settings" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Available functions: find_nearest_checkpoint returns the nearest checkpoint; show_all_checkpoints lists every checkpoint without selecting the nearest; start_match begins a match; open_settings opens preferences. The question selects a function only; it does not execute it.", questions={ "selecting_a_companion_function_for_a_spoken": Question_Choice( instructions="Which supplied function should the game companion select first?", criteria=[ Criterion(name="find_nearest_checkpoint"), Criterion(name="show_all_checkpoints"), Criterion(name="start_match"), Criterion(name="open_settings"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Available functions: find_nearest_checkpoint returns the nearest checkpoint; show_all_checkpoints lists every checkpoint without selecting the nearest; start_match begins a match; open_settings opens preferences. The question selects a function only; it does not execute it.", questions: { selecting_a_companion_function_for_a_spoken: { type: "choice", instructions: "Which supplied function should the game companion select first?", criteria: [ { name: "find_nearest_checkpoint" }, { name: "show_all_checkpoints" }, { name: "start_match" }, { name: "open_settings" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether the companion reply addresses the player's request How directly does the companion's reply address the question "How do I reopen the map?" Separate an on-topic reply from one that answers a different question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge relevance, not whether the control instructions are accurate for the game version.", "questions": { "whether_the_companion_reply_addresses": { "type": "score", "instructions": "How directly does the companion'\''s reply address the question \"How do I reopen the map?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge relevance, not whether the control instructions are accurate for the game version.", questions={ "whether_the_companion_reply_addresses": Question_Score( instructions="How directly does the companion's reply address the question \"How do I reopen the map?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge relevance, not whether the control instructions are accurate for the game version.", questions: { whether_the_companion_reply_addresses: { type: "score", instructions: "How directly does the companion's reply address the question \"How do I reopen the map?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background intrusion in a player's voice chat How intrusive is the background sound in this clip? Describe distracting background sound when teammates say a voice is difficult to hear. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_intrusion_in_a_players_voice_chat": { "type": "score", "instructions": "How intrusive is the background sound in this clip?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_intrusion_in_a_players_voice_chat": Question_Score( instructions="How intrusive is the background sound in this clip?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_intrusion_in_a_players_voice_chat: { type: "score", instructions: "How intrusive is the background sound in this clip?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The word stressed in a tactical callout Which supplied word carries the strongest emphasis? Identify which word in a recorded callout was stressed when reviewing a match. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The recorded teammate says, \"Defend the left gate.\" Describe the audible emphasis, not the correct tactic or the speaker'\''s intention.", "questions": { "the_word_stressed_in_a_tactical_callout": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Defend" }, { "name": "The" }, { "name": "Left" }, { "name": "Gate" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The recorded teammate says, \"Defend the left gate.\" Describe the audible emphasis, not the correct tactic or the speaker's intention.", questions={ "the_word_stressed_in_a_tactical_callout": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Defend"), Criterion(name="The"), Criterion(name="Left"), Criterion(name="Gate"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The recorded teammate says, \"Defend the left gate.\" Describe the audible emphasis, not the correct tactic or the speaker's intention.", questions: { the_word_stressed_in_a_tactical_callout: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Defend" }, { name: "The" }, { name: "Left" }, { name: "Gate" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A sound marked in a character take Which listed vocal sound is audible in this excerpt? Identify a selected vocal sound before a dialogue editor decides whether to trim it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_sound_marked_in_a_character_take": { "type": "choice", "instructions": "Which listed vocal sound is audible in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Other vocal sound" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_sound_marked_in_a_character_take": Question_Choice( instructions="Which listed vocal sound is audible in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Other vocal sound"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_sound_marked_in_a_character_take: { type: "choice", instructions: "Which listed vocal sound is audible in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Other vocal sound" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Marking laughter in a saved multiplayer transcript Where is laughter audible in this excerpt? Mark where laughter occurs in a text account of the exchange without guessing its meaning. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are measured from the start of the supplied excerpt.", "questions": { "marking_laughter_in_a_saved_multiplayer": { "type": "span", "instructions": "Where is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are measured from the start of the supplied excerpt.", questions={ "marking_laughter_in_a_saved_multiplayer": Question_Span( instructions="Where is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are measured from the start of the supplied excerpt.", questions: { marking_laughter_in_a_saved_multiplayer: { type: "span", instructions: "Where is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Technical quality of a received chat message How would most listeners rate the technical sound quality of this speech? Describe the received voice signal when a player reports a call-quality problem. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Rate the received voice-chat speech recording, separately from game sound design or the player'\''s communication skill.", "questions": { "technical_quality_of_a_received_chat_message": { "type": "score", "instructions": "How would most listeners rate the technical sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Rate the received voice-chat speech recording, separately from game sound design or the player's communication skill.", questions={ "technical_quality_of_a_received_chat_message": Question_Score( instructions="How would most listeners rate the technical sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Rate the received voice-chat speech recording, separately from game sound design or the player's communication skill.", questions: { technical_quality_of_a_received_chat_message: { type: "score", instructions: "How would most listeners rate the technical sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding a known callout in a match recording Where is the word "retreat" spoken in this voice-chat excerpt? Find where a known callout is spoken so the player can replay the surrounding exchange. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are measured from the start of the excerpt, not from game-state events.", "questions": { "finding_a_known_callout_in_a_match_recording": { "type": "span", "instructions": "Where is the word \"retreat\" spoken in this voice-chat excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are measured from the start of the excerpt, not from game-state events.", questions={ "finding_a_known_callout_in_a_match_recording": Question_Span( instructions="Where is the word \"retreat\" spoken in this voice-chat excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are measured from the start of the excerpt, not from game-state events.", questions: { finding_a_known_callout_in_a_match_recording: { type: "span", instructions: "Where is the word \"retreat\" spoken in this voice-chat excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Order of two tutorial cues Which word is spoken first: "wait" or "go"? Check an assembled recording against the intended cue sequence. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "order_of_two_tutorial_cues": { "type": "choice", "instructions": "Which word is spoken first: \"wait\" or \"go\"?", "criteria": [ { "name": "Wait" }, { "name": "Go" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "order_of_two_tutorial_cues": Question_Choice( instructions="Which word is spoken first: \"wait\" or \"go\"?", criteria=[ Criterion(name="Wait"), Criterion(name="Go"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { order_of_two_tutorial_cues: { type: "choice", instructions: "Which word is spoken first: \"wait\" or \"go\"?", criteria: [ { name: "Wait" }, { name: "Go" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise on a telehealth call How intrusive is the background noise? Send the audio the listener heard on the clinic or telehealth call. The answer rates the noise, not the medical content. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_on_a_telehealth_call": { "type": "score", "instructions": "How intrusive is the background noise?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_on_a_telehealth_call": Question_Score( instructions="How intrusive is the background noise?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_on_a_telehealth_call: { type: "score", instructions: "How intrusive is the background noise?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap in a follow-up call Do two people speak at the same time in this excerpt? Send the part of the exchange that is hard to follow. Both people may simply have started speaking at once. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_in_a_follow_up_call": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_in_a_follow_up_call": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_in_a_follow_up_call: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Routing an appointment request Which listed request is the caller making? List your service flows as options, such as booking an appointment, changing one and asking about a bill. The answer is the stated request, not a motive. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "routing_an_appointment_request": { "type": "choice", "instructions": "Which listed request is the caller making?", "criteria": [ { "name": "Book an appointment" }, { "name": "Change an appointment" }, { "name": "Ask about a bill" }, { "name": "Request clinic hours" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "routing_an_appointment_request": Question_Choice( instructions="Which listed request is the caller making?", criteria=[ Criterion(name="Book an appointment"), Criterion(name="Change an appointment"), Criterion(name="Ask about a bill"), Criterion(name="Request clinic hours"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { routing_an_appointment_request: { type: "choice", instructions: "Which listed request is the caller making?", criteria: [ { name: "Book an appointment" }, { name: "Change an appointment" }, { name: "Ask about a bill" }, { name: "Request clinic hours" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reply to a patient's question Does the reply address what the caller actually asked? Send a question such as "Do you have Saturday appointments?" with the full reply. The answer judges relevance, not whether the availability is right. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge relevance to \"Does the clinic have Saturday appointments?\", separately from whether the availability information is accurate or complete.", "questions": { "reply_to_a_patients_question": { "type": "score", "instructions": "Does the reply address what the caller actually asked?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge relevance to \"Does the clinic have Saturday appointments?\", separately from whether the availability information is accurate or complete.", questions={ "reply_to_a_patients_question": Question_Score( instructions="Does the reply address what the caller actually asked?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge relevance to \"Does the clinic have Saturday appointments?\", separately from whether the availability information is accurate or complete.", questions: { reply_to_a_patients_question: { type: "score", instructions: "Does the reply address what the caller actually asked?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language of a clinic call Which of the listed languages is spoken in this excerpt? Use the answer to suggest language support, then confirm with the caller. Calls in unlisted languages need separate handling. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "For this example, the clinic-call excerpt is known to use one of the five listed languages.", "questions": { "language_of_a_clinic_call": { "type": "choice", "instructions": "Which of the listed languages is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="For this example, the clinic-call excerpt is known to use one of the five listed languages.", questions={ "language_of_a_clinic_call": Question_Choice( instructions="Which of the listed languages is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "For this example, the clinic-call excerpt is known to use one of the five listed languages.", questions: { language_of_a_clinic_call: { type: "choice", instructions: "Which of the listed languages is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Technical quality of a clinic or telehealth call How would most listeners rate the technical sound quality of this speech? Describe recording quality when a participant says the connection is difficult to hear. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "technical_quality_of_a_clinic_or_telehealth_call": { "type": "score", "instructions": "How would most listeners rate the technical sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "technical_quality_of_a_clinic_or_telehealth_call": Question_Score( instructions="How would most listeners rate the technical sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { technical_quality_of_a_clinic_or_telehealth_call: { type: "score", instructions: "How would most listeners rate the technical sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a patient-experience quote Is laughter audible in this excerpt? Preserve an audible event in the quote record without inferring satisfaction, humor, diagnosis or who laughed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_patient_experience_quote": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_patient_experience_quote": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_patient_experience_quote: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether the caller received the information they asked for Did the reply give the requested appointment arrival time? Spot a specific unanswered administrative question before closing the conversation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Caller: \"What time should I arrive for my appointment?\" The staff reply follows in the recording. Judge whether the requested arrival time was actually supplied, not whether the reply was friendly or on-topic.", "questions": { "whether_the_caller_received_the_information_they": { "type": "choice", "instructions": "Did the reply give the requested appointment arrival time?", "criteria": [ { "name": "Yes" }, { "name": "Partly" }, { "name": "No" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Caller: \"What time should I arrive for my appointment?\" The staff reply follows in the recording. Judge whether the requested arrival time was actually supplied, not whether the reply was friendly or on-topic.", questions={ "whether_the_caller_received_the_information_they": Question_Choice( instructions="Did the reply give the requested appointment arrival time?", criteria=[ Criterion(name="Yes"), Criterion(name="Partly"), Criterion(name="No"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Caller: \"What time should I arrive for my appointment?\" The staff reply follows in the recording. Judge whether the requested arrival time was actually supplied, not whether the reply was friendly or on-topic.", questions: { whether_the_caller_received_the_information_they: { type: "choice", instructions: "Did the reply give the requested appointment arrival time?", criteria: [ { name: "Yes" }, { name: "Partly" }, { name: "No" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### How understandable an instruction sounds How much of the spoken instruction can be understood from this excerpt? Identify a spoken passage that may need repetition or clarification. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "how_understandable_an_instruction_sounds": { "type": "choice", "instructions": "How much of the spoken instruction can be understood from this excerpt?", "criteria": [ { "name": "All or nearly all" }, { "name": "Most" }, { "name": "About half" }, { "name": "Very little" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "how_understandable_an_instruction_sounds": Question_Choice( instructions="How much of the spoken instruction can be understood from this excerpt?", criteria=[ Criterion(name="All or nearly all"), Criterion(name="Most"), Criterion(name="About half"), Criterion(name="Very little"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { how_understandable_an_instruction_sounds: { type: "choice", instructions: "How much of the spoken instruction can be understood from this excerpt?", criteria: [ { name: "All or nearly all" }, { name: "Most" }, { name: "About half" }, { name: "Very little" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit response to an appointment offer How does the caller respond to the offered appointment? Record an observable response without treating it as legal/medical consent or proof of unspoken willingness. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains the appointment offer and the caller'\''s reply. Classify the caller'\''s reply only.", "questions": { "an_explicit_response_to_an_appointment_offer": { "type": "choice", "instructions": "How does the caller respond to the offered appointment?", "criteria": [ { "name": "Accepts the offered appointment" }, { "name": "Declines the offered appointment" }, { "name": "Asks a question or requests a different slot" }, { "name": "Mixed, something else or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains the appointment offer and the caller's reply. Classify the caller's reply only.", questions={ "an_explicit_response_to_an_appointment_offer": Question_Choice( instructions="How does the caller respond to the offered appointment?", criteria=[ Criterion(name="Accepts the offered appointment"), Criterion(name="Declines the offered appointment"), Criterion(name="Asks a question or requests a different slot"), Criterion(name="Mixed, something else or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains the appointment offer and the caller's reply. Classify the caller's reply only.", questions: { an_explicit_response_to_an_appointment_offer: { type: "choice", instructions: "How does the caller respond to the offered appointment?", criteria: [ { name: "Accepts the offered appointment" }, { name: "Declines the offered appointment" }, { name: "Asks a question or requests a different slot" }, { name: "Mixed, something else or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A quiet pause inside the patient's turn Is there a quiet pause of half a second or more within the patient's turn? Identify whether a quiet gap occurs while the patient still has the turn. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_quiet_pause_inside_the_patients_turn": { "type": "noul", "instructions": "Is there a quiet pause of half a second or more within the patient'\''s turn?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_quiet_pause_inside_the_patients_turn": Question_Noul( instructions="Is there a quiet pause of half a second or more within the patient's turn?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_quiet_pause_inside_the_patients_turn: { type: "noul", instructions: "Is there a quiet pause of half a second or more within the patient's turn?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### When the words and vocal delivery seem different Does the vocal delivery fit the supplied words, or sound noticeably different? Find a passage worth clarifying with the patient without calling it deception or suppressed emotion. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The patient says, \"I'\''m fine with that plan.\" Compare the audible delivery with those words; do not infer hidden reluctance or consent.", "questions": { "when_the_words_and_vocal_delivery_seem_different": { "type": "choice", "instructions": "Does the vocal delivery fit the supplied words, or sound noticeably different?", "criteria": [ { "name": "Delivery fits the words" }, { "name": "Delivery seems different" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The patient says, \"I'm fine with that plan.\" Compare the audible delivery with those words; do not infer hidden reluctance or consent.", questions={ "when_the_words_and_vocal_delivery_seem_different": Question_Choice( instructions="Does the vocal delivery fit the supplied words, or sound noticeably different?", criteria=[ Criterion(name="Delivery fits the words"), Criterion(name="Delivery seems different"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The patient says, \"I'm fine with that plan.\" Compare the audible delivery with those words; do not infer hidden reluctance or consent.", questions: { when_the_words_and_vocal_delivery_seem_different: { type: "choice", instructions: "Does the vocal delivery fit the supplied words, or sound noticeably different?", criteria: [ { name: "Delivery fits the words" }, { name: "Delivery seems different" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a patient's account Which word carries the strongest emphasis? Locate the stressed word before asking what the patient meant, rather than assigning a meaning to the stress. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The patient says, \"I didn'\''t think that would happen.\" Identify audible emphasis, not the patient'\''s intention.", "questions": { "emphasis_in_a_patients_account": { "type": "choice", "instructions": "Which word carries the strongest emphasis?", "criteria": [ { "name": "I" }, { "name": "Didn'\''t" }, { "name": "Think" }, { "name": "That" }, { "name": "Would" }, { "name": "Happen" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The patient says, \"I didn't think that would happen.\" Identify audible emphasis, not the patient's intention.", questions={ "emphasis_in_a_patients_account": Question_Choice( instructions="Which word carries the strongest emphasis?", criteria=[ Criterion(name="I"), Criterion(name="Didn't"), Criterion(name="Think"), Criterion(name="That"), Criterion(name="Would"), Criterion(name="Happen"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The patient says, \"I didn't think that would happen.\" Identify audible emphasis, not the patient's intention.", questions: { emphasis_in_a_patients_account: { type: "choice", instructions: "Which word carries the strongest emphasis?", criteria: [ { name: "I" }, { name: "Didn't" }, { name: "Think" }, { name: "That" }, { name: "Would" }, { name: "Happen" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The kind of noise interfering with a call Which listed background sound is audible underneath the voice? Give a concrete description of the sound without guessing its source. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_kind_of_noise_interfering_with_a_call": { "type": "choice", "instructions": "Which listed background sound is audible underneath the voice?", "criteria": [ { "name": "Hiss or steady static" }, { "name": "Low hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_kind_of_noise_interfering_with_a_call": Question_Choice( instructions="Which listed background sound is audible underneath the voice?", criteria=[ Criterion(name="Hiss or steady static"), Criterion(name="Low hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_kind_of_noise_interfering_with_a_call: { type: "choice", instructions: "Which listed background sound is audible underneath the voice?", criteria: [ { name: "Hiss or steady static" }, { name: "Low hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding the discussion of follow-up arrangements Where in this excerpt do the patient and clinic staff discuss follow-up appointment arrangements? Find the passages to replay rather than generate a clinical summary. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "finding_the_discussion_of_follow_up_arrangements": { "type": "span", "instructions": "Where in this excerpt do the patient and clinic staff discuss follow-up appointment arrangements?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "finding_the_discussion_of_follow_up_arrangements": Question_Span( instructions="Where in this excerpt do the patient and clinic staff discuss follow-up appointment arrangements?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { finding_the_discussion_of_follow_up_arrangements: { type: "span", instructions: "Where in this excerpt do the patient and clinic staff discuss follow-up appointment arrangements?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Which offered appointment the caller means Which offered appointment does "that one" refer to in the caller's reply? Avoid putting an unsupported date reference into a callback summary. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The selected recording runs from the offers of Tuesday morning and Thursday afternoon through the caller'\''s reply using \"that one.\" Use No clear reference if the exchange does not resolve the reference.", "questions": { "which_offered_appointment_the_caller_means": { "type": "choice", "instructions": "Which offered appointment does \"that one\" refer to in the caller'\''s reply?", "criteria": [ { "name": "Tuesday morning" }, { "name": "Thursday afternoon" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The selected recording runs from the offers of Tuesday morning and Thursday afternoon through the caller's reply using \"that one.\" Use No clear reference if the exchange does not resolve the reference.", questions={ "which_offered_appointment_the_caller_means": Question_Choice( instructions="Which offered appointment does \"that one\" refer to in the caller's reply?", criteria=[ Criterion(name="Tuesday morning"), Criterion(name="Thursday afternoon"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The selected recording runs from the offers of Tuesday morning and Thursday afternoon through the caller's reply using \"that one.\" Use No clear reference if the exchange does not resolve the reference.", questions: { which_offered_appointment_the_caller_means: { type: "choice", instructions: "Which offered appointment does \"that one\" refer to in the caller's reply?", criteria: [ { name: "Tuesday morning" }, { name: "Thursday afternoon" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A replay window for a coughing sound Where does coughing occur in this excerpt? Help someone find an audible event for a closer listen, without measuring a symptom. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_replay_window_for_a_coughing_sound": { "type": "span", "instructions": "Where does coughing occur in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_replay_window_for_a_coughing_sound": Question_Span( instructions="Where does coughing occur in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_replay_window_for_a_coughing_sound: { type: "span", instructions: "Where does coughing occur in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### More than one voice on the patient side of a call How many distinct speakers are audible in this excerpt? Clarify how many voices are audible before asking who is speaking. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "more_than_one_voice_on_the_patient_side": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "more_than_one_voice_on_the_patient_side": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { more_than_one_voice_on_the_patient_side: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music behind the caller Is background music audible behind the caller? Describe whether music is part of the background in a difficult-to-hear patient call. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_behind_the_caller": { "type": "noul", "instructions": "Is background music audible behind the caller?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_behind_the_caller": Question_Noul( instructions="Is background music audible behind the caller?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_behind_the_caller: { type: "noul", instructions: "Is background music audible behind the caller?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or taking over during a patient conversation Does the second speaker take over the turn, or briefly acknowledge while the first speaker continues? Make one turn-taking event clear enough to discuss without scoring the clinician's empathy. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "acknowledgment_or_taking_over_during_a_patient": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first speaker continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "acknowledgment_or_taking_over_during_a_patient": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first speaker continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { acknowledgment_or_taking_over_during_a_patient: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first speaker continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Speaking rate during a patient's explanation Is the speaking rate slow, moderate or fast? Describe how quickly the patient speaks in a selected passage, without treating pace as a symptom. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The selected passage is the patient'\''s explanation of why they called. Rate its pace—not its clarity, the patient'\''s distress or medical urgency.", "questions": { "speaking_rate_during_a_patients_explanation": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The selected passage is the patient's explanation of why they called. Rate its pace—not its clarity, the patient's distress or medical urgency.", questions={ "speaking_rate_during_a_patients_explanation": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The selected passage is the patient's explanation of why they called. Rate its pace—not its clarity, the patient's distress or medical urgency.", questions: { speaking_rate_during_a_patients_explanation: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Observable participation in a consultation exchange How does the selected patient reply contribute to the exchange? Describe what the person says or asks rather than infer whether they care or understand. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "observable_participation_in_a_consultation": { "type": "choice", "instructions": "How does the selected patient reply contribute to the exchange?", "criteria": [ { "name": "Asks a question" }, { "name": "Adds information or elaborates" }, { "name": "Gives a brief acknowledgment only" }, { "name": "Mixed or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "observable_participation_in_a_consultation": Question_Choice( instructions="How does the selected patient reply contribute to the exchange?", criteria=[ Criterion(name="Asks a question"), Criterion(name="Adds information or elaborates"), Criterion(name="Gives a brief acknowledgment only"), Criterion(name="Mixed or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { observable_participation_in_a_consultation: { type: "choice", instructions: "How does the selected patient reply contribute to the exchange?", criteria: [ { name: "Asks a question" }, { name: "Adds information or elaborates" }, { name: "Gives a brief acknowledgment only" }, { name: "Mixed or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Possible synthetic speech on the clinic phone line Does this clip appear to contain artificially generated speech? Support a manual review of an unusual call recording without deciding who is entitled to care. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "possible_synthetic_speech_on_the_clinic_phone": { "type": "noul", "instructions": "Does this clip appear to contain artificially generated speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "possible_synthetic_speech_on_the_clinic_phone": Question_Noul( instructions="Does this clip appear to contain artificially generated speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { possible_synthetic_speech_on_the_clinic_phone: { type: "noul", instructions: "Does this clip appear to contain artificially generated speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion expressed while discussing a concern Which emotion is conveyed by the speaker's voice in this excerpt? Describe the vocal expression in a selected patient utterance, not the patient's private feelings. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_expressed_while_discussing_a_concern": { "type": "choice", "instructions": "Which emotion is conveyed by the speaker'\''s voice in this excerpt?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_expressed_while_discussing_a_concern": Question_Choice( instructions="Which emotion is conveyed by the speaker's voice in this excerpt?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_expressed_while_discussing_a_concern: { type: "choice", instructions: "Which emotion is conveyed by the speaker's voice in this excerpt?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naming a vocal sound in a consultation recording Which listed vocal sound is audible in this excerpt? Make an audio note more specific without turning it into a clinical finding. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naming_a_vocal_sound_in_a_consultation_recording": { "type": "choice", "instructions": "Which listed vocal sound is audible in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Cry" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naming_a_vocal_sound_in_a_consultation_recording": Question_Choice( instructions="Which listed vocal sound is audible in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Cry"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naming_a_vocal_sound_in_a_consultation_recording: { type: "choice", instructions: "Which listed vocal sound is audible in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Cry" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Choosing the first tool for a clinic phone assistant Which supplied tool should the assistant select first? Illustrate an administrative next step without authorizing or executing it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Available tools: find_appointment_options — list available slots without changing a booking; transfer_to_staff — connect the caller to clinic staff; get_clinic_hours — return opening hours. Select a tool name only; this question does not execute a transfer or alter a booking.", "questions": { "choosing_the_first_tool_for_a_clinic_phone": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "find_appointment_options" }, { "name": "transfer_to_staff" }, { "name": "get_clinic_hours" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Available tools: find_appointment_options — list available slots without changing a booking; transfer_to_staff — connect the caller to clinic staff; get_clinic_hours — return opening hours. Select a tool name only; this question does not execute a transfer or alter a booking.", questions={ "choosing_the_first_tool_for_a_clinic_phone": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="find_appointment_options"), Criterion(name="transfer_to_staff"), Criterion(name="get_clinic_hours"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Available tools: find_appointment_options — list available slots without changing a booking; transfer_to_staff — connect the caller to clinic staff; get_clinic_hours — return opening hours. Select a tool name only; this question does not execute a transfer or alter a booking.", questions: { choosing_the_first_tool_for_a_clinic_phone: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "find_appointment_options" }, { name: "transfer_to_staff" }, { name: "get_clinic_hours" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Locating a pause within the patient's sentence After which supplied word does the speaker pause? Create a focused replay point for a clinician's clarification question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The consultation clip contains \"I felt better after lunch yesterday.\" Use the supplied transcript and candidate words to locate the audible pause; do not infer why it occurred or what caused the reported experience.", "questions": { "locating_a_pause_within_the_patients_sentence": { "type": "choice", "instructions": "After which supplied word does the speaker pause?", "criteria": [ { "name": "Felt" }, { "name": "Better" }, { "name": "After" }, { "name": "Lunch" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The consultation clip contains \"I felt better after lunch yesterday.\" Use the supplied transcript and candidate words to locate the audible pause; do not infer why it occurred or what caused the reported experience.", questions={ "locating_a_pause_within_the_patients_sentence": Question_Choice( instructions="After which supplied word does the speaker pause?", criteria=[ Criterion(name="Felt"), Criterion(name="Better"), Criterion(name="After"), Criterion(name="Lunch"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The consultation clip contains \"I felt better after lunch yesterday.\" Use the supplied transcript and candidate words to locate the audible pause; do not infer why it occurred or what caused the reported experience.", questions: { locating_a_pause_within_the_patients_sentence: { type: "choice", instructions: "After which supplied word does the speaker pause?", criteria: [ { name: "Felt" }, { name: "Better" }, { name: "After" }, { name: "Lunch" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of a clinic voice assistant's reply How natural does this speech sound? Review how the generated reply sounds during an actual administrative exchange. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_a_clinic_voice_assistants_reply": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_a_clinic_voice_assistants_reply": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_a_clinic_voice_assistants_reply: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses while describing a concern Are filled pauses such as "uh" or "um" audible in this excerpt? Describe audible filled pauses in the patient's spoken account, without interpreting their cause. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_while_describing_a_concern": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_while_describing_a_concern": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_while_describing_a_concern: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Policy service request Which listed request is the caller making? List service topics as options, such as policy documents, payments and claim status. The answer does not decide the request or assess coverage. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "policy_service_request": { "type": "choice", "instructions": "Which listed request is the caller making?", "criteria": [ { "name": "Request policy documents" }, { "name": "Ask about a payment" }, { "name": "Check claim status" }, { "name": "Change contact details" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "policy_service_request": Question_Choice( instructions="Which listed request is the caller making?", criteria=[ Criterion(name="Request policy documents"), Criterion(name="Ask about a payment"), Criterion(name="Check claim status"), Criterion(name="Change contact details"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { policy_service_request: { type: "choice", instructions: "Which listed request is the caller making?", criteria: [ { name: "Request policy documents" }, { name: "Ask about a payment" }, { name: "Check claim status" }, { name: "Change contact details" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Choosing a tool Which supplied tool should the assistant select first? List tool names as options, such as `get_required_document_list` and `get_claim_status`, each with a `description` of what it does. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The claim is already identified. Tools: get_required_document_list returns its requested-document checklist; get_claim_status returns status without that checklist; send_policy_copy sends policy wording, not the checklist; contact_claims_team requests human help. This question only selects a function.", "questions": { "choosing_a_tool": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "get_required_document_list", "description": "Returns the checklist of documents requested for a claim." }, { "name": "get_claim_status", "description": "Returns a claim'\''s status, without the document checklist." }, { "name": "send_policy_copy", "description": "Sends the policy wording, not the checklist." }, { "name": "contact_claims_team", "description": "Asks a person on the claims team for help." }, { "name": "None of these or unclear", "description": "No listed tool fits the request." } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The claim is already identified. Tools: get_required_document_list returns its requested-document checklist; get_claim_status returns status without that checklist; send_policy_copy sends policy wording, not the checklist; contact_claims_team requests human help. This question only selects a function.", questions={ "choosing_a_tool": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion( name="get_required_document_list", description="Returns the checklist of documents requested for a claim.", ), Criterion( name="get_claim_status", description="Returns a claim's status, without the document checklist.", ), Criterion( name="send_policy_copy", description="Sends the policy wording, not the checklist.", ), Criterion( name="contact_claims_team", description="Asks a person on the claims team for help.", ), Criterion( name="None of these or unclear", description="No listed tool fits the request.", ), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The claim is already identified. Tools: get_required_document_list returns its requested-document checklist; get_claim_status returns status without that checklist; send_policy_copy sends policy wording, not the checklist; contact_claims_team requests human help. This question only selects a function.", questions: { choosing_a_tool: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "get_required_document_list", description: "Returns the checklist of documents requested for a claim.", }, { name: "get_claim_status", description: "Returns a claim's status, without the document checklist.", }, { name: "send_policy_copy", description: "Sends the policy wording, not the checklist.", }, { name: "contact_claims_team", description: "Asks a person on the claims team for help.", }, { name: "None of these or unclear", description: "No listed tool fits the request.", }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### What a reference points to What does "those" refer to in this recorded exchange? List the earlier items as options, such as the photographs and the receipts, and add "None of these or unclear". On that answer, ask the caller instead of guessing. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Earlier in the recorded call, the caller mentions photographs of the damage and receipts for the repairs. The representative later says, \"Please upload those by Friday.\" Use None of these or unclear if the spoken context does not resolve what \"those\" refers to.", "questions": { "what_a_reference_points_to": { "type": "choice", "instructions": "What does \"those\" refer to in this recorded exchange?", "criteria": [ { "name": "The photographs" }, { "name": "The receipts" }, { "name": "Both groups of documents" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Earlier in the recorded call, the caller mentions photographs of the damage and receipts for the repairs. The representative later says, \"Please upload those by Friday.\" Use None of these or unclear if the spoken context does not resolve what \"those\" refers to.", questions={ "what_a_reference_points_to": Question_Choice( instructions="What does \"those\" refer to in this recorded exchange?", criteria=[ Criterion(name="The photographs"), Criterion(name="The receipts"), Criterion(name="Both groups of documents"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Earlier in the recorded call, the caller mentions photographs of the damage and receipts for the repairs. The representative later says, \"Please upload those by Friday.\" Use None of these or unclear if the spoken context does not resolve what \"those\" refers to.", questions: { what_a_reference_points_to: { type: "choice", instructions: "What does \"those\" refer to in this recorded exchange?", criteria: [ { name: "The photographs" }, { name: "The receipts" }, { name: "Both groups of documents" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap about documents Do two people speak at the same time in this excerpt? Send the exchange where the caller asks a question while the agent is explaining. On a yes, ask for unclear wording to be repeated. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_about_documents": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_about_documents": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_about_documents: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Clarify whether a document next step is being questioned Does the caller state "I will send a report" as their next step, or say it as a question about the instruction? Keep a questioned instruction from being recorded as a confirmed next step. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The representative says, \"Please send the damage report.\" The caller replies, \"I will send a report.\" Listen to whether the caller states a next step or questions the instruction.", "questions": { "clarify_whether_a_document_next_step_is_being": { "type": "choice", "instructions": "Does the caller state \"I will send a report\" as their next step, or say it as a question about the instruction?", "criteria": [ { "name": "States the next step" }, { "name": "Questions the instruction" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The representative says, \"Please send the damage report.\" The caller replies, \"I will send a report.\" Listen to whether the caller states a next step or questions the instruction.", questions={ "clarify_whether_a_document_next_step_is_being": Question_Choice( instructions="Does the caller state \"I will send a report\" as their next step, or say it as a question about the instruction?", criteria=[ Criterion(name="States the next step"), Criterion(name="Questions the instruction"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The representative says, \"Please send the damage report.\" The caller replies, \"I will send a report.\" Listen to whether the caller states a next step or questions the instruction.", questions: { clarify_whether_a_document_next_step_is_being: { type: "choice", instructions: "Does the caller state \"I will send a report\" as their next step, or say it as a question about the instruction?", criteria: [ { name: "States the next step" }, { name: "Questions the instruction" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a reply addresses the document question How directly does the representative's reply address the question "Can I upload photographs of the damage?" Distinguish relevance from correctness or a completed submission. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge whether the representative'\''s reply concerns the question \"Can I upload photographs of the damage?\"; do not verify the policy, legal requirements or whether anything was uploaded.", "questions": { "whether_a_reply_addresses_the_document_question": { "type": "score", "instructions": "How directly does the representative'\''s reply address the question \"Can I upload photographs of the damage?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge whether the representative's reply concerns the question \"Can I upload photographs of the damage?\"; do not verify the policy, legal requirements or whether anything was uploaded.", questions={ "whether_a_reply_addresses_the_document_question": Question_Score( instructions="How directly does the representative's reply address the question \"Can I upload photographs of the damage?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge whether the representative's reply concerns the question \"Can I upload photographs of the damage?\"; do not verify the policy, legal requirements or whether anything was uploaded.", questions: { whether_a_reply_addresses_the_document_question: { type: "score", instructions: "How directly does the representative's reply address the question \"Can I upload photographs of the damage?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Technical quality of an insurance service call How would most listeners rate the technical sound quality of this speech? Describe the audio when a caller cannot hear an explanation clearly. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "technical_quality_of_an_insurance_service_call": { "type": "score", "instructions": "How would most listeners rate the technical sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "technical_quality_of_an_insurance_service_call": Question_Score( instructions="How would most listeners rate the technical sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { technical_quality_of_an_insurance_service_call: { type: "score", instructions: "How would most listeners rate the technical sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background intrusion in a service voicemail How would most listeners rate the background sound, from very intrusive to not noticeable? Flag a difficult recording for closer listening before preparing its callback note. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_intrusion_in_a_service_voicemail": { "type": "score", "instructions": "How would most listeners rate the background sound, from very intrusive to not noticeable?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_intrusion_in_a_service_voicemail": Question_Score( instructions="How would most listeners rate the background sound, from very intrusive to not noticeable?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_intrusion_in_a_service_voicemail: { type: "score", instructions: "How would most listeners rate the background sound, from very intrusive to not noticeable?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or taking over a caller's explanation When the representative's voice comes in during the claimant's explanation, does the representative take over the turn, or briefly acknowledge while the claimant continues? Describe one moment where another voice enters before the first turn ends. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The claimant is the speaker explaining which documents they already sent; the representative is the voice entering during that explanation.", "questions": { "acknowledgment_or_taking_over_a_callers": { "type": "choice", "instructions": "When the representative'\''s voice comes in during the claimant'\''s explanation, does the representative take over the turn, or briefly acknowledge while the claimant continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The claimant is the speaker explaining which documents they already sent; the representative is the voice entering during that explanation.", questions={ "acknowledgment_or_taking_over_a_callers": Question_Choice( instructions="When the representative's voice comes in during the claimant's explanation, does the representative take over the turn, or briefly acknowledge while the claimant continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The claimant is the speaker explaining which documents they already sent; the representative is the voice entering during that explanation.", questions: { acknowledgment_or_taking_over_a_callers: { type: "choice", instructions: "When the representative's voice comes in during the claimant's explanation, does the representative take over the turn, or briefly acknowledge while the claimant continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion expressed in a claim-service conversation Which emotion is conveyed by the voice in this excerpt? Describe audible expression separately from the claim's merits. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_expressed_in_a_claim_service": { "type": "choice", "instructions": "Which emotion is conveyed by the voice in this excerpt?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_expressed_in_a_claim_service": Question_Choice( instructions="Which emotion is conveyed by the voice in this excerpt?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_expressed_in_a_claim_service: { type: "choice", instructions: "Which emotion is conveyed by the voice in this excerpt?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language support for a policyholder Which listed language is spoken in this excerpt? Identify a likely language before offering an appropriate communication channel. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The call is known to use one of the five listed languages.", "questions": { "language_support_for_a_policyholder": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The call is known to use one of the five listed languages.", questions={ "language_support_for_a_policyholder": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The call is known to use one of the five listed languages.", questions: { language_support_for_a_policyholder: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a document question Which supplied word carries the strongest emphasis? Identify the word a caller stresses before asking what they want clarified. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The caller asks, \"Do you need the original receipt?\" Identify the stressed word without inferring the intended meaning of the emphasis.", "questions": { "emphasis_in_a_document_question": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Do" }, { "name": "You" }, { "name": "Need" }, { "name": "The" }, { "name": "Original" }, { "name": "Receipt" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The caller asks, \"Do you need the original receipt?\" Identify the stressed word without inferring the intended meaning of the emphasis.", questions={ "emphasis_in_a_document_question": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Do"), Criterion(name="You"), Criterion(name="Need"), Criterion(name="The"), Criterion(name="Original"), Criterion(name="Receipt"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The caller asks, \"Do you need the original receipt?\" Identify the stressed word without inferring the intended meaning of the emphasis.", questions: { emphasis_in_a_document_question: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Do" }, { name: "You" }, { name: "Need" }, { name: "The" }, { name: "Original" }, { name: "Receipt" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Several voices in a policy-service call How many distinct speakers are audible in this excerpt? Clarify how many voices can be heard before a person confirms who is participating. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "several_voices_in_a_policy_service_call": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "several_voices_in_a_policy_service_call": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { several_voices_in_a_policy_service_call: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Filled pauses in a claim-service explanation Are filled pauses such as "uh" or "um" audible? Describe audible hesitation without treating it as proof about the reported event. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "filled_pauses_in_a_claim_service_explanation": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "filled_pauses_in_a_claim_service_explanation": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { filled_pauses_in_a_claim_service_explanation: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding where a submission deadline was discussed Find where the document-submission deadline is discussed. Locate a candidate replay passage for someone checking the wording of the conversation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the excerpt.", "questions": { "finding_where_a_submission_deadline_was": { "type": "span", "instructions": "Find where the document-submission deadline is discussed." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the excerpt.", questions={ "finding_where_a_submission_deadline_was": Question_Span( instructions="Find where the document-submission deadline is discussed.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the excerpt.", questions: { finding_where_a_submission_deadline_was: { type: "span", instructions: "Find where the document-submission deadline is discussed.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a recorded service-experience interview Is laughter audible in this excerpt? Preserve an audible event in the verbatim transcript before quoting the speaker. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_recorded_service_experience": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_recorded_service_experience": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_recorded_service_experience: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A vocal sound in a recorded account Which listed vocal sound is audible in this excerpt? Describe a non-word transcript marker without interpreting it as evidence about the event. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_vocal_sound_in_a_recorded_account": { "type": "choice", "instructions": "Which listed vocal sound is audible in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Cry" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_vocal_sound_in_a_recorded_account": Question_Choice( instructions="Which listed vocal sound is audible in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Cry"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_vocal_sound_in_a_recorded_account: { type: "choice", instructions: "Which listed vocal sound is audible in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Cry" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Repeated words in a caller's account Is a word said twice in a row in this excerpt? Describe an audible repetition without deciding why it occurred. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "repeated_words_in_a_callers_account": { "type": "noul", "instructions": "Is a word said twice in a row in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "repeated_words_in_a_callers_account": Question_Noul( instructions="Is a word said twice in a row in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { repeated_words_in_a_callers_account: { type: "noul", instructions: "Is a word said twice in a row in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of an insurance assistant's reply How natural does this speech sound? Review the sound of generated speech in an administrative exchange. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_an_insurance_assistants_reply": { "type": "score", "instructions": "How natural does this speech sound?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_an_insurance_assistants_reply": Question_Score( instructions="How natural does this speech sound?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_an_insurance_assistants_reply: { type: "score", instructions: "How natural does this speech sound?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Requested change Which listed change does the participant ask for first? List the features introduced in the session as options, such as larger print and an easier opening. The answer codes only what is said. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "requested_change": { "type": "choice", "instructions": "Which listed change does the participant ask for first?", "criteria": [ { "name": "Larger print" }, { "name": "Easier opening" }, { "name": "Smaller package" }, { "name": "A resealable closure" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "requested_change": Question_Choice( instructions="Which listed change does the participant ask for first?", criteria=[ Criterion(name="Larger print"), Criterion(name="Easier opening"), Criterion(name="Smaller package"), Criterion(name="A resealable closure"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { requested_change: { type: "choice", instructions: "Which listed change does the participant ask for first?", criteria: [ { name: "Larger print" }, { name: "Easier opening" }, { name: "Smaller package" }, { name: "A resealable closure" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Opinion of a product How positive or negative is the opinion expressed? Use levels from very negative to very positive. The answer separates praise from criticism, not purchase intent. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "opinion_of_a_product": { "type": "score", "instructions": "How positive or negative is the opinion expressed?", "criteria": ["Very negative", "Negative", "Neutral", "Positive", "Very positive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "opinion_of_a_product": Question_Score( instructions="How positive or negative is the opinion expressed?", criteria=["Very negative", "Negative", "Neutral", "Positive", "Very positive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { opinion_of_a_product: { type: "score", instructions: "How positive or negative is the opinion expressed?", criteria: ["Very negative", "Negative", "Neutral", "Positive", "Very positive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Which prototype is meant Which prototype does "that one" refer to in the reply? Send the exchange in which the prototypes are discussed, list them as options, and add "None of these or unclear". #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The selected exchange includes discussion of a blue box and a white pouch, followed by the participant saying \"that one.\" Use the audible preceding context; leave the reference unresolved if the exchange does not distinguish them.", "questions": { "which_prototype_is_meant": { "type": "choice", "instructions": "Which prototype does \"that one\" refer to in the reply?", "criteria": [ { "name": "Blue box" }, { "name": "White pouch" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The selected exchange includes discussion of a blue box and a white pouch, followed by the participant saying \"that one.\" Use the audible preceding context; leave the reference unresolved if the exchange does not distinguish them.", questions={ "which_prototype_is_meant": Question_Choice( instructions="Which prototype does \"that one\" refer to in the reply?", criteria=[ Criterion(name="Blue box"), Criterion(name="White pouch"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The selected exchange includes discussion of a blue box and a white pouch, followed by the participant saying \"that one.\" Use the audible preceding context; leave the reference unresolved if the exchange does not distinguish them.", questions: { which_prototype_is_meant: { type: "choice", instructions: "Which prototype does \"that one\" refer to in the reply?", criteria: [ { name: "Blue box" }, { name: "White pouch" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap in a focus group Do two people speak at the same time in this excerpt? Check unclear passages before attributing a quotation to a participant. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_in_a_focus_group": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_in_a_focus_group": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_in_a_focus_group: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding the packaging discussion Find where the sustained packaging discussion begins. Find a candidate passage for human review. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "finding_the_packaging_discussion": { "type": "span", "instructions": "Find where the sustained packaging discussion begins." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "finding_the_packaging_discussion": Question_Span( instructions="Find where the sustained packaging discussion begins.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { finding_the_packaging_discussion: { type: "span", instructions: "Find where the sustained packaging discussion begins.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit response to a suggestion Does the participant's reply explicitly agree or disagree with the moderator's suggestion that the package is easy to open? Keep an explicit objection from being summarized as agreement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains the moderator'\''s suggestion that the package is easy to open and the participant'\''s reply. Classify that reply only.", "questions": { "an_explicit_response_to_a_suggestion": { "type": "choice", "instructions": "Does the participant'\''s reply explicitly agree or disagree with the moderator'\''s suggestion that the package is easy to open?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Mixed, hedged, neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains the moderator's suggestion that the package is easy to open and the participant's reply. Classify that reply only.", questions={ "an_explicit_response_to_a_suggestion": Question_Choice( instructions="Does the participant's reply explicitly agree or disagree with the moderator's suggestion that the package is easy to open?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Mixed, hedged, neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains the moderator's suggestion that the package is easy to open and the participant's reply. Classify that reply only.", questions: { an_explicit_response_to_a_suggestion: { type: "choice", instructions: "Does the participant's reply explicitly agree or disagree with the moderator's suggestion that the package is easy to open?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Mixed, hedged, neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music beneath a remote interview Is music audible beneath the participant's speech? Record an audible condition that may complicate transcription. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_beneath_a_remote_interview": { "type": "noul", "instructions": "Is music audible beneath the participant'\''s speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_beneath_a_remote_interview": Question_Noul( instructions="Is music audible beneath the participant's speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_beneath_a_remote_interview: { type: "noul", instructions: "Is music audible beneath the participant's speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a quotation is understandable How much of the speech in this excerpt can a listener understand? Avoid presenting an uncertain interpretation as a confirmed quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "whether_a_quotation_is_understandable": { "type": "score", "instructions": "How much of the speech in this excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "whether_a_quotation_is_understandable": Question_Score( instructions="How much of the speech in this excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { whether_a_quotation_is_understandable: { type: "score", instructions: "How much of the speech in this excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The sample explicitly requested Which listed sample does the participant ask to see again? Select a stated next step without inferring which product the participant prefers. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The session offered a blue box, white pouch, green bottle and red tin. The selected reply supplies the request; count only a sample the participant explicitly asks to see again, and use the fallback if it names several or none of them.", "questions": { "the_sample_explicitly_requested": { "type": "choice", "instructions": "Which listed sample does the participant ask to see again?", "criteria": [ { "name": "Blue box" }, { "name": "White pouch" }, { "name": "Green bottle" }, { "name": "Red tin" }, { "name": "None, several or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The session offered a blue box, white pouch, green bottle and red tin. The selected reply supplies the request; count only a sample the participant explicitly asks to see again, and use the fallback if it names several or none of them.", questions={ "the_sample_explicitly_requested": Question_Choice( instructions="Which listed sample does the participant ask to see again?", criteria=[ Criterion(name="Blue box"), Criterion(name="White pouch"), Criterion(name="Green bottle"), Criterion(name="Red tin"), Criterion(name="None, several or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The session offered a blue box, white pouch, green bottle and red tin. The selected reply supplies the request; count only a sample the participant explicitly asks to see again, and use the fallback if it names several or none of them.", questions: { the_sample_explicitly_requested: { type: "choice", instructions: "Which listed sample does the participant ask to see again?", criteria: [ { name: "Blue box" }, { name: "White pouch" }, { name: "Green bottle" }, { name: "Red tin" }, { name: "None, several or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Interference in an interview passage How intrusive is the background sound in this interview passage? Describe background sound in a difficult-to-hear interview passage. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "interference_in_an_interview_passage": { "type": "score", "instructions": "How intrusive is the background sound in this interview passage?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "interference_in_an_interview_passage": Question_Score( instructions="How intrusive is the background sound in this interview passage?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { interference_in_an_interview_passage: { type: "score", instructions: "How intrusive is the background sound in this interview passage?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The type of vocal sound in an interview note Which listed vocal sound is audible in this excerpt? Replace a generic non-speech marker with a candidate sound label. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_type_of_vocal_sound_in_an_interview_note": { "type": "choice", "instructions": "Which listed vocal sound is audible in this excerpt?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Laugh" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_type_of_vocal_sound_in_an_interview_note": Question_Choice( instructions="Which listed vocal sound is audible in this excerpt?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Laugh"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_type_of_vocal_sound_in_an_interview_note: { type: "choice", instructions: "Which listed vocal sound is audible in this excerpt?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Laugh" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language in an incoming interview recording Which of the listed languages is spoken in this excerpt? Find the appropriate language-support path before transcription. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "For this example, the interview is known to use one of the five listed languages.", "questions": { "language_in_an_incoming_interview_recording": { "type": "choice", "instructions": "Which of the listed languages is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="For this example, the interview is known to use one of the five listed languages.", questions={ "language_in_an_incoming_interview_recording": Question_Choice( instructions="Which of the listed languages is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "For this example, the interview is known to use one of the five listed languages.", questions: { language_in_an_incoming_interview_recording: { type: "choice", instructions: "Which of the listed languages is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Fillers in a verbatim interview quote Are filled pauses such as "uh" or "um" audible? Flag a transcript detail for human confirmation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "fillers_in_a_verbatim_interview_quote": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "fillers_in_a_verbatim_interview_quote": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { fillers_in_a_verbatim_interview_quote: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A quiet pause within an interview answer Is there a quiet pause of half a second or more within the participant's answer, before another person speaks? Keep an audible gap separate from an interpretation of the participant's reaction. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_quiet_pause_within_an_interview_answer": { "type": "noul", "instructions": "Is there a quiet pause of half a second or more within the participant'\''s answer, before another person speaks?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_quiet_pause_within_an_interview_answer": Question_Noul( instructions="Is there a quiet pause of half a second or more within the participant's answer, before another person speaks?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_quiet_pause_within_an_interview_answer: { type: "noul", instructions: "Is there a quiet pause of half a second or more within the participant's answer, before another person speaks?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a participant's qualification Which word in "It works for me" carries the strongest emphasis? Keep a stressed qualification visible when choosing a quote. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emphasis_in_a_participants_qualification": { "type": "choice", "instructions": "Which word in \"It works for me\" carries the strongest emphasis?", "criteria": [ { "name": "It" }, { "name": "Works" }, { "name": "For" }, { "name": "Me" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emphasis_in_a_participants_qualification": Question_Choice( instructions="Which word in \"It works for me\" carries the strongest emphasis?", criteria=[ Criterion(name="It"), Criterion(name="Works"), Criterion(name="For"), Criterion(name="Me"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emphasis_in_a_participants_qualification: { type: "choice", instructions: "Which word in \"It works for me\" carries the strongest emphasis?", criteria: [ { name: "It" }, { name: "Works" }, { name: "For" }, { name: "Me" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A solo interview or a group exchange How many distinct speaking voices are audible? Help distinguish a single response from multi-voice discussion. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count distinct audible voices, not silent people; the count does not identify participants.", "questions": { "a_solo_interview_or_a_group_exchange": { "type": "choice", "instructions": "How many distinct speaking voices are audible?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count distinct audible voices, not silent people; the count does not identify participants.", questions={ "a_solo_interview_or_a_group_exchange": Question_Choice( instructions="How many distinct speaking voices are audible?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count distinct audible voices, not silent people; the count does not identify participants.", questions: { a_solo_interview_or_a_group_exchange: { type: "choice", instructions: "How many distinct speaking voices are audible?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether an interview response addresses the question How directly does the participant's reply address the question "What was difficult about opening the package?" Distinguish a relevant answer from a change of subject when organizing responses. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge whether the participant'\''s reply addresses \"What was difficult about opening the package?\", not whether the opinion is correct or sufficiently detailed.", "questions": { "whether_an_interview_response_addresses": { "type": "score", "instructions": "How directly does the participant'\''s reply address the question \"What was difficult about opening the package?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge whether the participant's reply addresses \"What was difficult about opening the package?\", not whether the opinion is correct or sufficiently detailed.", questions={ "whether_an_interview_response_addresses": Question_Score( instructions="How directly does the participant's reply address the question \"What was difficult about opening the package?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge whether the participant's reply addresses \"What was difficult about opening the package?\", not whether the opinion is correct or sufficiently detailed.", questions: { whether_an_interview_response_addresses: { type: "score", instructions: "How directly does the participant's reply address the question \"What was difficult about opening the package?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a research quotation Is laughter audible in this excerpt? Preserve an audible nonverbal event without interpreting it as delight, discomfort or agreement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_research_quotation": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_research_quotation": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_research_quotation: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or taking the floor? Does the moderator's overlapping "right" take over the turn or briefly acknowledge the participant? Help preserve a continuous quotation without treating every interjection as a new answer. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "acknowledgment_or_taking_the_floor": { "type": "choice", "instructions": "Does the moderator'\''s overlapping \"right\" take over the turn or briefly acknowledge the participant?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment without taking the floor" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "acknowledgment_or_taking_the_floor": Question_Choice( instructions="Does the moderator's overlapping \"right\" take over the turn or briefly acknowledge the participant?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment without taking the floor"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { acknowledgment_or_taking_the_floor: { type: "choice", instructions: "Does the moderator's overlapping \"right\" take over the turn or briefly acknowledge the participant?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment without taking the floor" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Questions versus short acknowledgments in an interview Which conversational move does the participant's reply to the moderator's feature explanation make? Describe the participant's observable response, not their level of engagement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "questions_versus_short_acknowledgments": { "type": "choice", "instructions": "Which conversational move does the participant'\''s reply to the moderator'\''s feature explanation make?", "criteria": [ { "name": "Asks a question" }, { "name": "Adds information" }, { "name": "Briefly acknowledges" }, { "name": "Mixed or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "questions_versus_short_acknowledgments": Question_Choice( instructions="Which conversational move does the participant's reply to the moderator's feature explanation make?", criteria=[ Criterion(name="Asks a question"), Criterion(name="Adds information"), Criterion(name="Briefly acknowledges"), Criterion(name="Mixed or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { questions_versus_short_acknowledgments: { type: "choice", instructions: "Which conversational move does the participant's reply to the moderator's feature explanation make?", criteria: [ { name: "Asks a question" }, { name: "Adds information" }, { name: "Briefly acknowledges" }, { name: "Mixed or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter for a scene Is laughter audible in this clip? Ask it of candidate clips for a scene or montage, then listen to the matches to pick one. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_for_a_scene": { "type": "noul", "instructions": "Is laughter audible in this clip?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_for_a_scene": Question_Noul( instructions="Is laughter audible in this clip?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_for_a_scene: { type: "noul", instructions: "Is laughter audible in this clip?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Fillers in an interview Are filled pauses such as "uh" or "um" audible? Flag takes to listen to before choosing which pauses to keep in a quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "fillers_in_an_interview": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "fillers_in_an_interview": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { fillers_in_an_interview: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Crosstalk in an answer Do two people speak at the same time in this passage? Check whether the interviewer overlaps an answer before cutting it as a quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "crosstalk_in_an_answer": { "type": "noul", "instructions": "Do two people speak at the same time in this passage?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "crosstalk_in_an_answer": Question_Noul( instructions="Do two people speak at the same time in this passage?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { crosstalk_in_an_answer: { type: "noul", instructions: "Do two people speak at the same time in this passage?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background in a take How intrusive is the background sound? Use levels from not noticeable to very intrusive. An editor still decides whether to use the take. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_in_a_take": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_in_a_take": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_in_a_take: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding a discussion within a long interview Find the parts of the interview discussing bridge renovation. Find relevant sections to replay while assembling a rough cut. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the supplied audio.", "questions": { "finding_a_discussion_within_a_long_interview": { "type": "span", "instructions": "Find the parts of the interview discussing bridge renovation." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the supplied audio.", questions={ "finding_a_discussion_within_a_long_interview": Question_Span( instructions="Find the parts of the interview discussing bridge renovation.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the supplied audio.", questions: { finding_a_discussion_within_a_long_interview: { type: "span", instructions: "Find the parts of the interview discussing bridge renovation.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A pause near a proposed interview cut After which supplied word is there an audible pause? Suggest a word-relative listening point for a shorter quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The interview passage says, \"We finished the repairs on Friday. Then we opened the doors for the first time.\" Locate the audible pause relative to the supplied words.", "questions": { "a_pause_near_a_proposed_interview_cut": { "type": "choice", "instructions": "After which supplied word is there an audible pause?", "criteria": [ { "name": "Repairs" }, { "name": "Friday" }, { "name": "Opened" }, { "name": "Doors" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The interview passage says, \"We finished the repairs on Friday. Then we opened the doors for the first time.\" Locate the audible pause relative to the supplied words.", questions={ "a_pause_near_a_proposed_interview_cut": Question_Choice( instructions="After which supplied word is there an audible pause?", criteria=[ Criterion(name="Repairs"), Criterion(name="Friday"), Criterion(name="Opened"), Criterion(name="Doors"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The interview passage says, \"We finished the repairs on Friday. Then we opened the doors for the first time.\" Locate the audible pause relative to the supplied words.", questions: { a_pause_near_a_proposed_interview_cut: { type: "choice", instructions: "After which supplied word is there an audible pause?", criteria: [ { name: "Repairs" }, { name: "Friday" }, { name: "Opened" }, { name: "Doors" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a narration line Which supplied word carries the emphasis? Check a concrete performance direction before selecting the take. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Supplied narration: \"The museum opens today.\" Identify the prominence actually heard.", "questions": { "emphasis_in_a_narration_line": { "type": "choice", "instructions": "Which supplied word carries the emphasis?", "criteria": [ { "name": "The" }, { "name": "Museum" }, { "name": "Opens" }, { "name": "Today" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Supplied narration: \"The museum opens today.\" Identify the prominence actually heard.", questions={ "emphasis_in_a_narration_line": Question_Choice( instructions="Which supplied word carries the emphasis?", criteria=[ Criterion(name="The"), Criterion(name="Museum"), Criterion(name="Opens"), Criterion(name="Today"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Supplied narration: \"The museum opens today.\" Identify the prominence actually heard.", questions: { emphasis_in_a_narration_line: { type: "choice", instructions: "Which supplied word carries the emphasis?", criteria: [ { name: "The" }, { name: "Museum" }, { name: "Opens" }, { name: "Today" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A nonverbal cue in a podcast recording Which listed nonverbal vocal sound is audible? Replace a generic marker with a bounded vocal-sound label for human confirmation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_nonverbal_cue_in_a_podcast_recording": { "type": "choice", "instructions": "Which listed nonverbal vocal sound is audible?", "criteria": [ { "name": "Cough" }, { "name": "Breath" }, { "name": "Other vocal sound" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_nonverbal_cue_in_a_podcast_recording": Question_Choice( instructions="Which listed nonverbal vocal sound is audible?", criteria=[ Criterion(name="Cough"), Criterion(name="Breath"), Criterion(name="Other vocal sound"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_nonverbal_cue_in_a_podcast_recording: { type: "choice", instructions: "Which listed nonverbal vocal sound is audible?", criteria: [ { name: "Cough" }, { name: "Breath" }, { name: "Other vocal sound" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An interviewer's acknowledgment within an answer Does the second voice take over the turn, or briefly acknowledge while the first speaker continues? Distinguish a brief interjection from a change of speaker turn before shortening an interview. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_interviewers_acknowledgment_within_an_answer": { "type": "choice", "instructions": "Does the second voice take over the turn, or briefly acknowledge while the first speaker continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_interviewers_acknowledgment_within_an_answer": Question_Choice( instructions="Does the second voice take over the turn, or briefly acknowledge while the first speaker continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_interviewers_acknowledgment_within_an_answer: { type: "choice", instructions: "Does the second voice take over the turn, or briefly acknowledge while the first speaker continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Expression in a selected interview answer Which listed emotion does the voice convey? Describe how a quoted line sounds without assigning the interviewee a private feeling. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "expression_in_a_selected_interview_answer": { "type": "choice", "instructions": "Which listed emotion does the voice convey?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "expression_in_a_selected_interview_answer": Question_Choice( instructions="Which listed emotion does the voice convey?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { expression_in_a_selected_interview_answer: { type: "choice", instructions: "Which listed emotion does the voice convey?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language in an interview recording Which of the listed languages is spoken in this clip? Identify which language track an interview clip belongs with. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The clip is known, for this example, to use one of the five listed languages.", "questions": { "language_in_an_interview_recording": { "type": "choice", "instructions": "Which of the listed languages is spoken in this clip?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The clip is known, for this example, to use one of the five listed languages.", questions={ "language_in_an_interview_recording": Question_Choice( instructions="Which of the listed languages is spoken in this clip?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The clip is known, for this example, to use one of the five listed languages.", questions: { language_in_an_interview_recording: { type: "choice", instructions: "Which of the listed languages is spoken in this clip?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Check voice continuity after replacing a narration line Does the replacement line sound like the same voice as the surrounding narration? Check perceived voice continuity after replacing a narration line. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The listening file plays an original narration excerpt, the replacement line, then the original excerpt again. Compare the perceived voice continuity across the edit.", "questions": { "check_voice_continuity_after_replacing": { "type": "score", "instructions": "Does the replacement line sound like the same voice as the surrounding narration?", "criteria": ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The listening file plays an original narration excerpt, the replacement line, then the original excerpt again. Compare the perceived voice continuity across the edit.", questions={ "check_voice_continuity_after_replacing": Question_Score( instructions="Does the replacement line sound like the same voice as the surrounding narration?", criteria=["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The listening file plays an original narration excerpt, the replacement line, then the original excerpt again. Compare the perceived voice continuity across the edit.", questions: { check_voice_continuity_after_replacing: { type: "score", instructions: "Does the replacement line sound like the same voice as the surrounding narration?", criteria: ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Understandable words in a field interview How much of the speech in this excerpt can be understood? Check a passage whose words are hard to make out before it is quoted. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "understandable_words_in_a_field_interview": { "type": "score", "instructions": "How much of the speech in this excerpt can be understood?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "understandable_words_in_a_field_interview": Question_Score( instructions="How much of the speech in this excerpt can be understood?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { understandable_words_in_a_field_interview: { type: "score", instructions: "How much of the speech in this excerpt can be understood?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The kind of background sound in a location recording Which listed background sound is audible underneath the voice? Name the audible noise when discussing an audio problem in a take. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_kind_of_background_sound_in_a_location": { "type": "choice", "instructions": "Which listed background sound is audible underneath the voice?", "criteria": [ { "name": "Hiss or static" }, { "name": "Low hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_kind_of_background_sound_in_a_location": Question_Choice( instructions="Which listed background sound is audible underneath the voice?", criteria=[ Criterion(name="Hiss or static"), Criterion(name="Low hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_kind_of_background_sound_in_a_location: { type: "choice", instructions: "Which listed background sound is audible underneath the voice?", criteria: [ { name: "Hiss or static" }, { name: "Low hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter missing from a podcast transcript Is laughter audible in this excerpt? Add a descriptive sound note without interpreting why anyone laughed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_missing_from_a_podcast_transcript": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_missing_from_a_podcast_transcript": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_missing_from_a_podcast_transcript: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit response in an interview Does the guest's reply explicitly agree or disagree with the description? Avoid presenting an explicit objection as endorsement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains the interviewer'\''s description of the project and the guest'\''s reply. Classify that reply.", "questions": { "an_explicit_response_in_an_interview": { "type": "choice", "instructions": "Does the guest'\''s reply explicitly agree or disagree with the description?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Mixed, qualified, neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains the interviewer's description of the project and the guest's reply. Classify that reply.", questions={ "an_explicit_response_in_an_interview": Question_Choice( instructions="Does the guest's reply explicitly agree or disagree with the description?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Mixed, qualified, neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains the interviewer's description of the project and the guest's reply. Classify that reply.", questions: { an_explicit_response_in_an_interview: { type: "choice", instructions: "Does the guest's reply explicitly agree or disagree with the description?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Mixed, qualified, neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Voices in a panel interview excerpt How many distinct speakers are audible in this excerpt? Describe the audible speaker count before separating interview turns in an edit. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count the voices heard in the selected passage, not the people visible on camera or silent participants.", "questions": { "voices_in_a_panel_interview_excerpt": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count the voices heard in the selected passage, not the people visible on camera or silent participants.", questions={ "voices_in_a_panel_interview_excerpt": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count the voices heard in the selected passage, not the people visible on camera or silent participants.", questions: { voices_in_a_panel_interview_excerpt: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A decision reported in an interview Which decision does the speaker say the garden group reached? Keep the clip log faithful to the decision the speaker actually reports. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_decision_reported_in_an_interview": { "type": "choice", "instructions": "Which decision does the speaker say the garden group reached?", "criteria": [ { "name": "Move the garden to a new site" }, { "name": "Set up a shared volunteer rota" }, { "name": "Grow vegetables for a food bank" }, { "name": "Extend the opening hours" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_decision_reported_in_an_interview": Question_Choice( instructions="Which decision does the speaker say the garden group reached?", criteria=[ Criterion(name="Move the garden to a new site"), Criterion(name="Set up a shared volunteer rota"), Criterion(name="Grow vegetables for a food bank"), Criterion(name="Extend the opening hours"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_decision_reported_in_an_interview: { type: "choice", instructions: "Which decision does the speaker say the garden group reached?", criteria: [ { name: "Move the garden to a new site" }, { name: "Set up a shared volunteer rota" }, { name: "Grow vegetables for a food bank" }, { name: "Extend the opening hours" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music already mixed into an interview quote Is background music audible behind the speech? Check whether an interview excerpt already carries a music bed before adding another soundtrack. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_already_mixed_into_an_interview_quote": { "type": "noul", "instructions": "Is background music audible behind the speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_already_mixed_into_an_interview_quote": Question_Noul( instructions="Is background music audible behind the speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_already_mixed_into_an_interview_quote: { type: "noul", instructions: "Is background music audible behind the speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An editor's spoken request to a media assistant Which supplied tool should the assistant select first? Illustrate choosing an editing-support tool without changing the project. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Available tools: search_transcripts — search recorded interview transcripts; play_clip — play a clip already selected; export_sequence — export an existing edit. Select a tool name only; do not execute it.", "questions": { "an_editors_spoken_request_to_a_media_assistant": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "search_transcripts" }, { "name": "play_clip" }, { "name": "export_sequence" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Available tools: search_transcripts — search recorded interview transcripts; play_clip — play a clip already selected; export_sequence — export an existing edit. Select a tool name only; do not execute it.", questions={ "an_editors_spoken_request_to_a_media_assistant": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="search_transcripts"), Criterion(name="play_clip"), Criterion(name="export_sequence"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Available tools: search_transcripts — search recorded interview transcripts; play_clip — play a clip already selected; export_sequence — export an existing edit. Select a tool name only; do not execute it.", questions: { an_editors_spoken_request_to_a_media_assistant: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "search_transcripts" }, { name: "play_clip" }, { name: "export_sequence" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Naturalness of generated narration How natural does the synthesized narration sound? Give perceptual feedback on a generated voice performance. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "naturalness_of_generated_narration": { "type": "score", "instructions": "How natural does the synthesized narration sound?", "criteria": ["Very unnatural", "Unnatural", "Neither natural nor unnatural", "Natural", "Very natural"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "naturalness_of_generated_narration": Question_Score( instructions="How natural does the synthesized narration sound?", criteria=["Very unnatural", "Unnatural", "Neither natural nor unnatural", "Natural", "Very natural"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { naturalness_of_generated_narration: { type: "score", instructions: "How natural does the synthesized narration sound?", criteria: ["Very unnatural", "Unnatural", "Neither natural nor unnatural", "Natural", "Very natural"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pace of an explainer narration Is the speaking rate slow, moderate or fast? Describe the pace when a narrated section feels rushed or slow. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "pace_of_an_explainer_narration": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "pace_of_an_explainer_narration": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { pace_of_an_explainer_narration: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter for a montage Is laughter audible in this excerpt? An editor still checks who is laughing and whether the moment suits the sequence. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_for_a_montage": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_for_a_montage": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_for_a_montage: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Happy-sounding reaction Which listed emotion does the voice convey? List emotions such as sad and happy, and add "Neutral" and "None of these or unclear". The answer is the audible expression, not the speaker's feelings. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "happy_sounding_reaction": { "type": "choice", "instructions": "Which listed emotion does the voice convey?", "criteria": [ { "name": "Sad" }, { "name": "Disgusted" }, { "name": "Fearful" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "happy_sounding_reaction": Question_Choice( instructions="Which listed emotion does the voice convey?", criteria=[ Criterion(name="Sad"), Criterion(name="Disgusted"), Criterion(name="Fearful"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { happy_sounding_reaction: { type: "choice", instructions: "Which listed emotion does the voice convey?", criteria: [ { name: "Sad" }, { name: "Disgusted" }, { name: "Fearful" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Running tap Can a running water tap be heard? Ask it of ambience recordings before an editor picks the usable part. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "running_tap": { "type": "noul", "instructions": "Can a running water tap be heard?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "running_tap": Question_Noul( instructions="Can a running water tap be heard?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { running_tap: { type: "noul", instructions: "Can a running water tap be heard?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a topic within an interview Find the parts of this interview discussing the renovation. Find the relevant parts of an interview to replay. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Interval times are relative to the supplied audio'\''s beginning.", "questions": { "find_a_topic_within_an_interview": { "type": "span", "instructions": "Find the parts of this interview discussing the renovation." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Interval times are relative to the supplied audio's beginning.", questions={ "find_a_topic_within_an_interview": Question_Span( instructions="Find the parts of this interview discussing the renovation.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Interval times are relative to the supplied audio's beginning.", questions: { find_a_topic_within_an_interview: { type: "span", instructions: "Find the parts of this interview discussing the renovation.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a quoted word in a recording Find where "Friday" is spoken in this recording. Open the relevant part of a candidate recording for listening. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "find_a_quoted_word_in_a_recording": { "type": "span", "instructions": "Find where \"Friday\" is spoken in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "find_a_quoted_word_in_a_recording": Question_Span( instructions="Find where \"Friday\" is spoken in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { find_a_quoted_word_in_a_recording: { type: "span", instructions: "Find where \"Friday\" is spoken in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Choosing a first action for a spoken media search Which supplied tool should the assistant select first? Illustrate a search assistant's next step with explicit tool definitions. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Available tools: search_transcripts — search episode transcripts; play_selected_episode — play an already selected episode; show_saved_clips — list saved clips. Choose only a tool name; no tool is executed by this question.", "questions": { "choosing_a_first_action_for_a_spoken_media": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "search_transcripts" }, { "name": "play_selected_episode" }, { "name": "show_saved_clips" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Available tools: search_transcripts — search episode transcripts; play_selected_episode — play an already selected episode; show_saved_clips — list saved clips. Choose only a tool name; no tool is executed by this question.", questions={ "choosing_a_first_action_for_a_spoken_media": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="search_transcripts"), Criterion(name="play_selected_episode"), Criterion(name="show_saved_clips"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Available tools: search_transcripts — search episode transcripts; play_selected_episode — play an already selected episode; show_saved_clips — list saved clips. Choose only a tool name; no tool is executed by this question.", questions: { choosing_a_first_action_for_a_spoken_media: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "search_transcripts" }, { name: "play_selected_episode" }, { name: "show_saved_clips" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An environmental sound among supplied types Which listed sound can be heard? Narrow a sound-library candidate to a known kind of sound. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_environmental_sound_among_supplied_types": { "type": "choice", "instructions": "Which listed sound can be heard?", "criteria": [ { "name": "Speech" }, { "name": "Dog" }, { "name": "Vacuum cleaner" }, { "name": "Alarm bell ringing" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_environmental_sound_among_supplied_types": Question_Choice( instructions="Which listed sound can be heard?", criteria=[ Criterion(name="Speech"), Criterion(name="Dog"), Criterion(name="Vacuum cleaner"), Criterion(name="Alarm bell ringing"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_environmental_sound_among_supplied_types: { type: "choice", instructions: "Which listed sound can be heard?", criteria: [ { name: "Speech" }, { name: "Dog" }, { name: "Vacuum cleaner" }, { name: "Alarm bell ringing" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Understandable words in a candidate interview quote How much of the speech in this excerpt can be understood? Check whether the words in a promising search result can be made out. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "understandable_words_in_a_candidate_interview": { "type": "score", "instructions": "How much of the speech in this excerpt can be understood?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "understandable_words_in_a_candidate_interview": Question_Score( instructions="How much of the speech in this excerpt can be understood?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { understandable_words_in_a_candidate_interview: { type: "score", instructions: "How much of the speech in this excerpt can be understood?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A fast-spoken passage in a clip collection Is the speaking rate slow, moderate or fast? Find candidate passages with a requested delivery pace. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Tag the selected candidate'\''s pace, not its importance or the speaker'\''s emotional state.", "questions": { "a_fast_spoken_passage_in_a_clip_collection": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Tag the selected candidate's pace, not its importance or the speaker's emotional state.", questions={ "a_fast_spoken_passage_in_a_clip_collection": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Tag the selected candidate's pace, not its importance or the speaker's emotional state.", questions: { a_fast_spoken_passage_in_a_clip_collection: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A turn takeover rather than a brief acknowledgment Does the second speaker take over the turn, or briefly acknowledge while the first continues? Find an example of a particular conversational event, not a rude person. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_turn_takeover_rather_than_a_brief": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_turn_takeover_rather_than_a_brief": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_turn_takeover_rather_than_a_brief: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A title named in a spoken search request Which series is the person asking to find? Pass the named catalogue value into a separate search step. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The recorded request asks for one of these catalogue series: \"City Walks,\" \"Night Kitchen,\" \"Game Notes\" or \"Garden Hour.\"", "questions": { "a_title_named_in_a_spoken_search_request": { "type": "choice", "instructions": "Which series is the person asking to find?", "criteria": [ { "name": "City Walks" }, { "name": "Night Kitchen" }, { "name": "Game Notes" }, { "name": "Garden Hour" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The recorded request asks for one of these catalogue series: \"City Walks,\" \"Night Kitchen,\" \"Game Notes\" or \"Garden Hour.\"", questions={ "a_title_named_in_a_spoken_search_request": Question_Choice( instructions="Which series is the person asking to find?", criteria=[ Criterion(name="City Walks"), Criterion(name="Night Kitchen"), Criterion(name="Game Notes"), Criterion(name="Garden Hour"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The recorded request asks for one of these catalogue series: \"City Walks,\" \"Night Kitchen,\" \"Game Notes\" or \"Garden Hour.\"", questions: { a_title_named_in_a_spoken_search_request: { type: "choice", instructions: "Which series is the person asking to find?", criteria: [ { name: "City Walks" }, { name: "Night Kitchen" }, { name: "Game Notes" }, { name: "Garden Hour" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding a quote without background music Is music audible in this excerpt? Avoid selecting a quote that already contains an unwanted music bed. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "finding_a_quote_without_background_music": { "type": "noul", "instructions": "Is music audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "finding_a_quote_without_background_music": Question_Noul( instructions="Is music audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { finding_a_quote_without_background_music: { type: "noul", instructions: "Is music audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Accent for a supplied voiceover brief Which listed accent does the voice most resemble? Narrow candidate recordings for the supplied production brief. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Describe the clip'\''s audible accent rather than a person'\''s background.", "questions": { "accent_for_a_supplied_voiceover_brief": { "type": "choice", "instructions": "Which listed accent does the voice most resemble?", "criteria": [ { "name": "Mainstream US English" }, { "name": "South African English" }, { "name": "Neither or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Describe the clip's audible accent rather than a person's background.", questions={ "accent_for_a_supplied_voiceover_brief": Question_Choice( instructions="Which listed accent does the voice most resemble?", criteria=[ Criterion(name="Mainstream US English"), Criterion(name="South African English"), Criterion(name="Neither or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Describe the clip's audible accent rather than a person's background.", questions: { accent_for_a_supplied_voiceover_brief: { type: "choice", instructions: "Which listed accent does the voice most resemble?", criteria: [ { name: "Mainstream US English" }, { name: "South African English" }, { name: "Neither or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A single-voice or multi-voice candidate How many distinct speakers are audible in this clip? Distinguish candidate clip formats before choosing an interview excerpt. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count only voices in the supplied candidate; do not identify people or infer who is present but silent.", "questions": { "a_single_voice_or_multi_voice_candidate": { "type": "choice", "instructions": "How many distinct speakers are audible in this clip?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count only voices in the supplied candidate; do not identify people or infer who is present but silent.", questions={ "a_single_voice_or_multi_voice_candidate": Question_Choice( instructions="How many distinct speakers are audible in this clip?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count only voices in the supplied candidate; do not identify people or infer who is present but silent.", questions: { a_single_voice_or_multi_voice_candidate: { type: "choice", instructions: "How many distinct speakers are audible in this clip?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language tags for unlabelled archive clips Which listed language is spoken in this clip? Narrow a known multilingual collection before listening to search results. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "For this example, the archive candidates are known to contain speech in English, Japanese, Arabic, French or Russian.", "questions": { "language_tags_for_unlabelled_archive_clips": { "type": "choice", "instructions": "Which listed language is spoken in this clip?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="For this example, the archive candidates are known to contain speech in English, Japanese, Arabic, French or Russian.", questions={ "language_tags_for_unlabelled_archive_clips": Question_Choice( instructions="Which listed language is spoken in this clip?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "For this example, the archive candidates are known to contain speech in English, Japanese, Arabic, French or Russian.", questions: { language_tags_for_unlabelled_archive_clips: { type: "choice", instructions: "Which listed language is spoken in this clip?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit refusal in a candidate exchange Does the reply explicitly refuse the request? Find a literal conversational move without inferring whether the speaker is unwilling in private. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt includes the request and the reply. If the reply is qualified, indirect or unclear, choose Mixed or unclear.", "questions": { "an_explicit_refusal_in_a_candidate_exchange": { "type": "choice", "instructions": "Does the reply explicitly refuse the request?", "criteria": [ { "name": "Explicit refusal" }, { "name": "No explicit refusal" }, { "name": "Mixed or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt includes the request and the reply. If the reply is qualified, indirect or unclear, choose Mixed or unclear.", questions={ "an_explicit_refusal_in_a_candidate_exchange": Question_Choice( instructions="Does the reply explicitly refuse the request?", criteria=[ Criterion(name="Explicit refusal"), Criterion(name="No explicit refusal"), Criterion(name="Mixed or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt includes the request and the reply. If the reply is qualified, indirect or unclear, choose Mixed or unclear.", questions: { an_explicit_refusal_in_a_candidate_exchange: { type: "choice", instructions: "Does the reply explicitly refuse the request?", criteria: [ { name: "Explicit refusal" }, { name: "No explicit refusal" }, { name: "Mixed or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A quote without competing speakers Do two speakers talk at the same time in this excerpt? Flag candidates that need careful replay before a clean quote is selected. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_quote_without_competing_speakers": { "type": "noul", "instructions": "Do two speakers talk at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_quote_without_competing_speakers": Question_Noul( instructions="Do two speakers talk at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_quote_without_competing_speakers: { type: "noul", instructions: "Do two speakers talk at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Sound quality of a phone interview excerpt How would most listeners rate the technical sound quality of this speech? Prioritize technically clearer candidates for a human listen. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The candidate is a phone or VoIP interview recording. Rate the technical quality of the speech signal, separately from what the speaker says.", "questions": { "sound_quality_of_a_phone_interview_excerpt": { "type": "score", "instructions": "How would most listeners rate the technical sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The candidate is a phone or VoIP interview recording. Rate the technical quality of the speech signal, separately from what the speaker says.", questions={ "sound_quality_of_a_phone_interview_excerpt": Question_Score( instructions="How would most listeners rate the technical sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The candidate is a phone or VoIP interview recording. Rate the technical quality of the speech signal, separately from what the speaker says.", questions: { sound_quality_of_a_phone_interview_excerpt: { type: "score", instructions: "How would most listeners rate the technical sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A clip containing an explicit offer or promise Which listed conversational move does the speaker make? Narrow candidate excerpts for an editor to confirm against the brief. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_clip_containing_an_explicit_offer_or_promise": { "type": "choice", "instructions": "Which listed conversational move does the speaker make?", "criteria": [ { "name": "Asking someone to act" }, { "name": "Reporting information" }, { "name": "Offering or promising an action" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_clip_containing_an_explicit_offer_or_promise": Question_Choice( instructions="Which listed conversational move does the speaker make?", criteria=[ Criterion(name="Asking someone to act"), Criterion(name="Reporting information"), Criterion(name="Offering or promising an action"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_clip_containing_an_explicit_offer_or_promise: { type: "choice", instructions: "Which listed conversational move does the speaker make?", criteria: [ { name: "Asking someone to act" }, { name: "Reporting information" }, { name: "Offering or promising an action" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The noise type in an archive candidate Which listed background sound is audible underneath the voice? Add an audible-type tag to distinguish noisy candidates. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_noise_type_in_an_archive_candidate": { "type": "choice", "instructions": "Which listed background sound is audible underneath the voice?", "criteria": [ { "name": "Hiss or static" }, { "name": "Low hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_noise_type_in_an_archive_candidate": Question_Choice( instructions="Which listed background sound is audible underneath the voice?", criteria=[ Criterion(name="Hiss or static"), Criterion(name="Low hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_noise_type_in_an_archive_candidate: { type: "choice", instructions: "Which listed background sound is audible underneath the voice?", criteria: [ { name: "Hiss or static" }, { name: "Low hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A clip emphasizing a target word Which supplied word carries the strongest emphasis? Find candidate delivery that matches a specific spoken emphasis. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The supplied sentence is \"This is our home\". Identify the audible emphasis.", "questions": { "a_clip_emphasizing_a_target_word": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "This" }, { "name": "Is" }, { "name": "Our" }, { "name": "Home" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The supplied sentence is \"This is our home\". Identify the audible emphasis.", questions={ "a_clip_emphasizing_a_target_word": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="This"), Criterion(name="Is"), Criterion(name="Our"), Criterion(name="Home"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The supplied sentence is \"This is our home\". Identify the audible emphasis.", questions: { a_clip_emphasizing_a_target_word: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "This" }, { name: "Is" }, { name: "Our" }, { name: "Home" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Natural-sounding generated narration candidates How would most listeners rate the naturalness of this generated narration? Compare a speech-quality impression across candidate generated recordings. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "natural_sounding_generated_narration_candidates": { "type": "score", "instructions": "How would most listeners rate the naturalness of this generated narration?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "natural_sounding_generated_narration_candidates": Question_Score( instructions="How would most listeners rate the naturalness of this generated narration?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { natural_sounding_generated_narration_candidates: { type: "score", instructions: "How would most listeners rate the naturalness of this generated narration?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Act in a reported reply Does the speaker ask for an action, report information or offer an action? Send the reply with the nearby conversation, and add "None of these or unclear" as an option. The answer does not decide whether a rule was broken. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "act_in_a_reported_reply": { "type": "choice", "instructions": "Does the speaker ask for an action, report information or offer an action?", "criteria": [ { "name": "Asks someone to act" }, { "name": "Reports information" }, { "name": "Offers or promises an action" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "act_in_a_reported_reply": Question_Choice( instructions="Does the speaker ask for an action, report information or offer an action?", criteria=[ Criterion(name="Asks someone to act"), Criterion(name="Reports information"), Criterion(name="Offers or promises an action"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { act_in_a_reported_reply: { type: "choice", instructions: "Does the speaker ask for an action, report information or offer an action?", criteria: [ { name: "Asks someone to act" }, { name: "Reports information" }, { name: "Offers or promises an action" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Reply to a request to stop How does the other person explicitly respond to "Please stop"? List options such as agrees, refuses and apologizes, and add "None of these or unclear". The answer labels the reply, not whether the conduct stopped. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The selected short exchange includes \"Please stop\" and the other person'\''s reply immediately afterward. Classify that reply only.", "questions": { "reply_to_a_request_to_stop": { "type": "choice", "instructions": "How does the other person explicitly respond to \"Please stop\"?", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly refuses" }, { "name": "Apologizes" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The selected short exchange includes \"Please stop\" and the other person's reply immediately afterward. Classify that reply only.", questions={ "reply_to_a_request_to_stop": Question_Choice( instructions="How does the other person explicitly respond to \"Please stop\"?", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly refuses"), Criterion(name="Apologizes"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The selected short exchange includes \"Please stop\" and the other person's reply immediately afterward. Classify that reply only.", questions: { reply_to_a_request_to_stop: { type: "choice", instructions: "How does the other person explicitly respond to \"Please stop\"?", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly refuses" }, { name: "Apologizes" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap around a reported phrase Do two people speak at the same time in this excerpt? Check before a reviewer attributes the reported phrase. The answer does not say who said it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_around_a_reported_phrase": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_around_a_reported_phrase": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_around_a_reported_phrase: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find a reported phrase in a recording Find where "leave me alone" is spoken in this recording. Locate the quoted passage without assuming it is a policy violation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Return intervals measured from the beginning of the supplied audio.", "questions": { "find_a_reported_phrase_in_a_recording": { "type": "span", "instructions": "Find where \"leave me alone\" is spoken in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Return intervals measured from the beginning of the supplied audio.", questions={ "find_a_reported_phrase_in_a_recording": Question_Span( instructions="Find where \"leave me alone\" is spoken in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Return intervals measured from the beginning of the supplied audio.", questions: { find_a_reported_phrase_in_a_recording: { type: "span", instructions: "Find where \"leave me alone\" is spoken in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Identify a non-speech sound in a reported clip Which of the listed sounds is audible in this excerpt? Describe an audible event so a reviewer can check it in context. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "identify_a_non_speech_sound_in_a_reported_clip": { "type": "choice", "instructions": "Which of the listed sounds is audible in this excerpt?", "criteria": [ { "name": "Screaming" }, { "name": "Crying" }, { "name": "Gunshot-like sound" }, { "name": "Several of these" }, { "name": "Another sound or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "identify_a_non_speech_sound_in_a_reported_clip": Question_Choice( instructions="Which of the listed sounds is audible in this excerpt?", criteria=[ Criterion(name="Screaming"), Criterion(name="Crying"), Criterion(name="Gunshot-like sound"), Criterion(name="Several of these"), Criterion(name="Another sound or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { identify_a_non_speech_sound_in_a_reported_clip: { type: "choice", instructions: "Which of the listed sounds is audible in this excerpt?", criteria: [ { name: "Screaming" }, { name: "Crying" }, { name: "Gunshot-like sound" }, { name: "Several of these" }, { name: "Another sound or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Triage a reported exchange against a supplied policy Which review label best describes this exchange under the supplied rule? Organize a reported exchange for human review under an explicitly supplied rule. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Supplied example platform rule: \"Repeatedly directing personal insults at another participant after they have asked for it to stop is disallowed. Quoting an insult to report it is not itself a violation of this rule.\"", "questions": { "triage_a_reported_exchange_against_a_supplied": { "type": "choice", "instructions": "Which review label best describes this exchange under the supplied rule?", "criteria": [ { "name": "Matches the rule'\''s prohibited conduct" }, { "name": "Does not match the rule'\''s prohibited conduct" }, { "name": "Insufficient context" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Supplied example platform rule: \"Repeatedly directing personal insults at another participant after they have asked for it to stop is disallowed. Quoting an insult to report it is not itself a violation of this rule.\"", questions={ "triage_a_reported_exchange_against_a_supplied": Question_Choice( instructions="Which review label best describes this exchange under the supplied rule?", criteria=[ Criterion(name="Matches the rule's prohibited conduct"), Criterion(name="Does not match the rule's prohibited conduct"), Criterion(name="Insufficient context"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Supplied example platform rule: \"Repeatedly directing personal insults at another participant after they have asked for it to stop is disallowed. Quoting an insult to report it is not itself a violation of this rule.\"", questions: { triage_a_reported_exchange_against_a_supplied: { type: "choice", instructions: "Which review label best describes this exchange under the supplied rule?", criteria: [ { name: "Matches the rule's prohibited conduct" }, { name: "Does not match the rule's prohibited conduct" }, { name: "Insufficient context" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a reply addresses a question in a reported conversation How directly does the reply address the question "Why are you messaging me again?" Check whether a reply addresses the preceding question in a reported exchange. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "In this audio conversation between two participants, one asks, \"Why are you messaging me again?\" Assess whether the other participant'\''s reply addresses the question, not whether it is true, appropriate or a policy violation.", "questions": { "whether_a_reply_addresses_a_question": { "type": "score", "instructions": "How directly does the reply address the question \"Why are you messaging me again?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="In this audio conversation between two participants, one asks, \"Why are you messaging me again?\" Assess whether the other participant's reply addresses the question, not whether it is true, appropriate or a policy violation.", questions={ "whether_a_reply_addresses_a_question": Question_Score( instructions="How directly does the reply address the question \"Why are you messaging me again?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "In this audio conversation between two participants, one asks, \"Why are you messaging me again?\" Assess whether the other participant's reply addresses the question, not whether it is true, appropriate or a policy violation.", questions: { whether_a_reply_addresses_a_question: { type: "score", instructions: "How directly does the reply address the question \"Why are you messaging me again?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background interference in a reported clip How intrusive is the background sound? Describe the audible interference rather than guessing the words through it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_interference_in_a_reported_clip": { "type": "score", "instructions": "How intrusive is the background sound?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_interference_in_a_reported_clip": Question_Score( instructions="How intrusive is the background sound?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_interference_in_a_reported_clip: { type: "score", instructions: "How intrusive is the background sound?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A filled pause in a disputed quotation Are filled pauses such as "uh" or "um" audible? Check whether a verbatim quotation omits an audible filled pause. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_filled_pause_in_a_disputed_quotation": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_filled_pause_in_a_disputed_quotation": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_filled_pause_in_a_disputed_quotation: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in the reported sentence Which supplied word carries the strongest emphasis? Locate stress without assigning sarcasm or hostile intent. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The attached clip contains \"Please leave me alone.\" Identify a stressed candidate word, not the meaning or policy status of the sentence.", "questions": { "emphasis_in_the_reported_sentence": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Please" }, { "name": "Leave" }, { "name": "Me" }, { "name": "Alone" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The attached clip contains \"Please leave me alone.\" Identify a stressed candidate word, not the meaning or policy status of the sentence.", questions={ "emphasis_in_the_reported_sentence": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Please"), Criterion(name="Leave"), Criterion(name="Me"), Criterion(name="Alone"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The attached clip contains \"Please leave me alone.\" Identify a stressed candidate word, not the meaning or policy status of the sentence.", questions: { emphasis_in_the_reported_sentence: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Please" }, { name: "Leave" }, { name: "Me" }, { name: "Alone" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Audible delivery style in a reported passage Which listed delivery style is audible? Add an audible delivery description for replay without treating it as aggression. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "audible_delivery_style_in_a_reported_passage": { "type": "choice", "instructions": "Which listed delivery style is audible?", "criteria": [ { "name": "Shouting" }, { "name": "Whispering" }, { "name": "Laughing while speaking" }, { "name": "Ordinary speaking voice" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "audible_delivery_style_in_a_reported_passage": Question_Choice( instructions="Which listed delivery style is audible?", criteria=[ Criterion(name="Shouting"), Criterion(name="Whispering"), Criterion(name="Laughing while speaking"), Criterion(name="Ordinary speaking voice"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { audible_delivery_style_in_a_reported_passage: { type: "choice", instructions: "Which listed delivery style is audible?", criteria: [ { name: "Shouting" }, { name: "Whispering" }, { name: "Laughing while speaking" }, { name: "Ordinary speaking voice" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Synthetic-origin question for an audio attachment Does this clip appear to contain artificially generated speech? Keep audio-origin uncertainty separate from the truth of a report. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "synthetic_origin_question_for_an_audio": { "type": "noul", "instructions": "Does this clip appear to contain artificially generated speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "synthetic_origin_question_for_an_audio": Question_Noul( instructions="Does this clip appear to contain artificially generated speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { synthetic_origin_question_for_an_audio: { type: "noul", instructions: "Does this clip appear to contain artificially generated speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A nonverbal event omitted from a report transcript Is laughter audible in this excerpt? Preserve an event for context without labelling it as mockery or enjoyment. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_nonverbal_event_omitted_from_a_report": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_nonverbal_event_omitted_from_a_report": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_nonverbal_event_omitted_from_a_report: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A takeover or acknowledgment around a reported remark Does the second speaker take over the turn, or briefly acknowledge while the first continues? Describe one turn transition without interpreting courtesy or hostility. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_takeover_or_acknowledgment_around_a_reported": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_takeover_or_acknowledgment_around_a_reported": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_takeover_or_acknowledgment_around_a_reported: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Can the reported words be made out? How much of the speech in this excerpt can a listener understand? Keep a difficult-to-hear attachment from being treated as a verified quote. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "can_the_reported_words_be_made_out": { "type": "score", "instructions": "How much of the speech in this excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "can_the_reported_words_be_made_out": Question_Score( instructions="How much of the speech in this excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { can_the_reported_words_be_made_out: { type: "score", instructions: "How much of the speech in this excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Where a speaker pauses within the quoted line After which supplied word does the speaker pause? Locate a pause relative to supplied words without interpreting why it occurred. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Supplied line: \"I never said you should leave.\"", "questions": { "where_a_speaker_pauses_within_the_quoted_line": { "type": "choice", "instructions": "After which supplied word does the speaker pause?", "criteria": [ { "name": "Never" }, { "name": "Said" }, { "name": "You" }, { "name": "Should" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Supplied line: \"I never said you should leave.\"", questions={ "where_a_speaker_pauses_within_the_quoted_line": Question_Choice( instructions="After which supplied word does the speaker pause?", criteria=[ Criterion(name="Never"), Criterion(name="Said"), Criterion(name="You"), Criterion(name="Should"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Supplied line: \"I never said you should leave.\"", questions: { where_a_speaker_pauses_within_the_quoted_line: { type: "choice", instructions: "After which supplied word does the speaker pause?", criteria: [ { name: "Never" }, { name: "Said" }, { name: "You" }, { name: "Should" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find laughter in a reported recording Find the first audible laughter in this reported excerpt. Help a person replay a sound that a text report leaves out. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "find_laughter_in_a_reported_recording": { "type": "span", "instructions": "Find the first audible laughter in this reported excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "find_laughter_in_a_reported_recording": Question_Span( instructions="Find the first audible laughter in this reported excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { find_laughter_in_a_reported_recording: { type: "span", instructions: "Find the first audible laughter in this reported excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music behind the reported words Is background music audible underneath the speech? Describe an audio obstacle without guessing the words it covers. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_behind_the_reported_words": { "type": "noul", "instructions": "Is background music audible underneath the speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_behind_the_reported_words": Question_Noul( instructions="Is background music audible underneath the speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_behind_the_reported_words: { type: "noul", instructions: "Is background music audible underneath the speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language for a human report review Which listed language is spoken in this reported clip? Suggest a language-skilled reviewer without interpreting the clip as a policy violation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "language_for_a_human_report_review": { "type": "choice", "instructions": "Which listed language is spoken in this reported clip?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "Unclear or another language" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "language_for_a_human_report_review": Question_Choice( instructions="Which listed language is spoken in this reported clip?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="Unclear or another language"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { language_for_a_human_report_review: { type: "choice", instructions: "Which listed language is spoken in this reported clip?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "Unclear or another language" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### How many voices need to be heard? How many distinct voices are audible in this excerpt? Provide limited listening context for the reported recording. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "how_many_voices_need_to_be_heard": { "type": "choice", "instructions": "How many distinct voices are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "how_many_voices_need_to_be_heard": Question_Choice( instructions="How many distinct voices are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { how_many_voices_need_to_be_heard: { type: "choice", instructions: "How many distinct voices are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Follow-up from a planning call Which action is explicitly assigned in this excerpt? List candidate actions as options, such as sending the interview schedule, and add "None of these or unclear". A coordinator confirms the owner and deadline. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "follow_up_from_a_planning_call": { "type": "choice", "instructions": "Which action is explicitly assigned in this excerpt?", "criteria": [ { "name": "Send the interview schedule" }, { "name": "Book a meeting room" }, { "name": "Send the meeting link" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "follow_up_from_a_planning_call": Question_Choice( instructions="Which action is explicitly assigned in this excerpt?", criteria=[ Criterion(name="Send the interview schedule"), Criterion(name="Book a meeting room"), Criterion(name="Send the meeting link"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { follow_up_from_a_planning_call: { type: "choice", instructions: "Which action is explicitly assigned in this excerpt?", criteria: [ { name: "Send the interview schedule" }, { name: "Book a meeting room" }, { name: "Send the meeting link" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise in an interview recording How intrusive is the background noise? Send a short excerpt from a phone or video interview, and use levels from not noticeable to very intrusive. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_in_an_interview_recording": { "type": "score", "instructions": "How intrusive is the background noise?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_in_an_interview_recording": Question_Score( instructions="How intrusive is the background noise?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_in_an_interview_recording: { type: "score", instructions: "How intrusive is the background noise?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Candidate's reply on topic How directly does the candidate's reply address the interviewer's question? Send the question with the full reply. The answer judges whether the reply stays on the question, not whether it is true or shows fit for the role. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The interviewer asks, \"What steps did you take when the project requirements changed?\" Check whether the candidate'\''s recorded reply stays on that question, not whether the account is true or demonstrates suitability for the job.", "questions": { "candidates_reply_on_topic": { "type": "score", "instructions": "How directly does the candidate'\''s reply address the interviewer'\''s question?", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The interviewer asks, \"What steps did you take when the project requirements changed?\" Check whether the candidate's recorded reply stays on that question, not whether the account is true or demonstrates suitability for the job.", questions={ "candidates_reply_on_topic": Question_Score( instructions="How directly does the candidate's reply address the interviewer's question?", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The interviewer asks, \"What steps did you take when the project requirements changed?\" Check whether the candidate's recorded reply stays on that question, not whether the account is true or demonstrates suitability for the job.", questions: { candidates_reply_on_topic: { type: "score", instructions: "How directly does the candidate's reply address the interviewer's question?", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap before transcription Do two people speak at the same time in this excerpt? Check a passage before its transcript goes into interview notes. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_before_transcription": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_before_transcription": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_before_transcription: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Find the interview next steps Find the parts of this recording where the recruiter explains the next interview stage and how it will be scheduled. Find the logistical instructions in a recruiting recording so they are easy to revisit. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Search the supplied excerpt and return intervals relative to its start.", "questions": { "find_the_interview_next_steps": { "type": "span", "instructions": "Find the parts of this recording where the recruiter explains the next interview stage and how it will be scheduled." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Search the supplied excerpt and return intervals relative to its start.", questions={ "find_the_interview_next_steps": Question_Span( instructions="Find the parts of this recording where the recruiter explains the next interview stage and how it will be scheduled.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Search the supplied excerpt and return intervals relative to its start.", questions: { find_the_interview_next_steps: { type: "span", instructions: "Find the parts of this recording where the recruiter explains the next interview stage and how it will be scheduled.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Fillers in a recruiting video Are filled pauses such as "uh" or "um" audible in this excerpt? Flag a careers-video excerpt for an editor to listen to before deciding whether to trim it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "fillers_in_a_recruiting_video": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "fillers_in_a_recruiting_video": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { fillers_in_a_recruiting_video: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language labels for careers videos Which of the listed languages is spoken in this excerpt? Help a recruiting content team organize multilingual recordings before preparing captions. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "This excerpt belongs to a collection recorded in English, Japanese, Arabic, French or Russian.", "questions": { "language_labels_for_careers_videos": { "type": "choice", "instructions": "Which of the listed languages is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="This excerpt belongs to a collection recorded in English, Japanese, Arabic, French or Russian.", questions={ "language_labels_for_careers_videos": Question_Choice( instructions="Which of the listed languages is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "This excerpt belongs to a collection recorded in English, Japanese, Arabic, French or Russian.", questions: { language_labels_for_careers_videos: { type: "choice", instructions: "Which of the listed languages is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Delivery against a careers-video brief How strongly would listeners agree that the voice expresses the intended upbeat, welcoming tone for this line? Help a recruiting content producer review a recorded welcome against the intended tone. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The recorded line is \"Welcome! Here is what to expect when you apply.\" The production direction is upbeat and welcoming. Review the recorded delivery against that direction.", "questions": { "delivery_against_a_careers_video_brief": { "type": "score", "instructions": "How strongly would listeners agree that the voice expresses the intended upbeat, welcoming tone for this line?", "criteria": ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The recorded line is \"Welcome! Here is what to expect when you apply.\" The production direction is upbeat and welcoming. Review the recorded delivery against that direction.", questions={ "delivery_against_a_careers_video_brief": Question_Score( instructions="How strongly would listeners agree that the voice expresses the intended upbeat, welcoming tone for this line?", criteria=["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The recorded line is \"Welcome! Here is what to expect when you apply.\" The production direction is upbeat and welcoming. Review the recorded delivery against that direction.", questions: { delivery_against_a_careers_video_brief: { type: "score", instructions: "How strongly would listeners agree that the voice expresses the intended upbeat, welcoming tone for this line?", criteria: ["Do not agree at all", "Disagree", "Neutral", "Agree", "Fully agree"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A reply to a proposed interview time How does the reply respond to the proposed time "Would Thursday at 2 p.m. work for your interview?" Help a coordinator distinguish an explicit acceptance from a question before confirming a booking. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The excerpt contains \"Would Thursday at 2 p.m. work for your interview?\" and the reply. Classify the explicit reply.", "questions": { "a_reply_to_a_proposed_interview_time": { "type": "choice", "instructions": "How does the reply respond to the proposed time \"Would Thursday at 2 p.m. work for your interview?\"", "criteria": [ { "name": "Explicitly agrees" }, { "name": "Explicitly disagrees" }, { "name": "Asks a question" }, { "name": "Qualified, something else or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The excerpt contains \"Would Thursday at 2 p.m. work for your interview?\" and the reply. Classify the explicit reply.", questions={ "a_reply_to_a_proposed_interview_time": Question_Choice( instructions="How does the reply respond to the proposed time \"Would Thursday at 2 p.m. work for your interview?\"", criteria=[ Criterion(name="Explicitly agrees"), Criterion(name="Explicitly disagrees"), Criterion(name="Asks a question"), Criterion(name="Qualified, something else or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The excerpt contains \"Would Thursday at 2 p.m. work for your interview?\" and the reply. Classify the explicit reply.", questions: { a_reply_to_a_proposed_interview_time: { type: "choice", instructions: "How does the reply respond to the proposed time \"Would Thursday at 2 p.m. work for your interview?\"", criteria: [ { name: "Explicitly agrees" }, { name: "Explicitly disagrees" }, { name: "Asks a question" }, { name: "Qualified, something else or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Single-speaker clips from a careers panel How many distinct speakers are audible in this excerpt? Help an editor check whether a selected panel excerpt contains one voice or several before making a short clip. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count audible voices, not attendees.", "questions": { "single_speaker_clips_from_a_careers_panel": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count audible voices, not attendees.", questions={ "single_speaker_clips_from_a_careers_panel": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count audible voices, not attendees.", questions: { single_speaker_clips_from_a_careers_panel: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background noise in a recorded interview Does this audio have noise behind the talker? Help a coordinator identify a recording that may need closer listening before transcription. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_noise_in_a_recorded_interview": { "type": "noul", "instructions": "Does this audio have noise behind the talker?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_noise_in_a_recorded_interview": Question_Noul( instructions="Does this audio have noise behind the talker?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_noise_in_a_recorded_interview: { type: "noul", instructions: "Does this audio have noise behind the talker?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An explicit scheduling request Which listed request does the speaker explicitly make? Help a coordinator sort incoming voice messages before replying. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_explicit_scheduling_request": { "type": "choice", "instructions": "Which listed request does the speaker explicitly make?", "criteria": [ { "name": "Reschedule an interview" }, { "name": "Ask for the meeting link" }, { "name": "Ask what to prepare" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_explicit_scheduling_request": Question_Choice( instructions="Which listed request does the speaker explicitly make?", criteria=[ Criterion(name="Reschedule an interview"), Criterion(name="Ask for the meeting link"), Criterion(name="Ask what to prepare"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_explicit_scheduling_request: { type: "choice", instructions: "Which listed request does the speaker explicitly make?", criteria: [ { name: "Reschedule an interview" }, { name: "Ask for the meeting link" }, { name: "Ask what to prepare" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter in a careers event recording Does a speaker or listener laugh in this excerpt? Help an editor find promising excerpts for a careers-event highlight reel. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_in_a_careers_event_recording": { "type": "noul", "instructions": "Does a speaker or listener laugh in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_in_a_careers_event_recording": Question_Noul( instructions="Does a speaker or listener laugh in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_in_a_careers_event_recording: { type: "noul", instructions: "Does a speaker or listener laugh in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Fillers in a clip Are filled pauses such as "uh" or "um" audible? Flag clips for a listen before editing. The answer says whether fillers are present, not where. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "fillers_in_a_clip": { "type": "noul", "instructions": "Are filled pauses such as \"uh\" or \"um\" audible?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "fillers_in_a_clip": Question_Noul( instructions="Are filled pauses such as \"uh\" or \"um\" audible?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { fillers_in_a_clip: { type: "noul", instructions: "Are filled pauses such as \"uh\" or \"um\" audible?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Crosstalk before captioning Do two people speak at the same time in this excerpt? Flag street-interview passages for a closer listen before captioning. The answer does not say who said which words. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "crosstalk_before_captioning": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "crosstalk_before_captioning": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { crosstalk_before_captioning: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language tag Which listed language is spoken in this excerpt? List the languages your clips use as options, and have a person confirm the tag before captioning. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The clip is known to use one of the five listed languages.", "questions": { "language_tag": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The clip is known to use one of the five listed languages.", questions={ "language_tag": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The clip is known to use one of the five listed languages.", questions: { language_tag: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Quality before posting How would most listeners rate the sound quality of this speech? Check a recording before it is posted. The answer rates the sound, not which defect causes it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "quality_before_posting": { "type": "score", "instructions": "How would most listeners rate the sound quality of this speech?", "criteria": ["Bad", "Poor", "Fair", "Good", "Excellent"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "quality_before_posting": Question_Score( instructions="How would most listeners rate the sound quality of this speech?", criteria=["Bad", "Poor", "Fair", "Good", "Excellent"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { quality_before_posting: { type: "score", instructions: "How would most listeners rate the sound quality of this speech?", criteria: ["Bad", "Poor", "Fair", "Good", "Excellent"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding a discussion for a chapter marker Find where the main battery-life discussion begins. Find a candidate chapter location for human verification. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "finding_a_discussion_for_a_chapter_marker": { "type": "span", "instructions": "Find where the main battery-life discussion begins." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( questions={ "finding_a_discussion_for_a_chapter_marker": Question_Span( instructions="Find where the main battery-life discussion begins.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { finding_a_discussion_for_a_chapter_marker: { type: "span", instructions: "Find where the main battery-life discussion begins.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A request, report or commitment Does the speaker ask for an action, report information, commit to an action, or express a reaction? Make a follow-up list from explicit conversational moves, without assuming an offer will be fulfilled. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_request_report_or_commitment": { "type": "choice", "instructions": "Does the speaker ask for an action, report information, commit to an action, or express a reaction?", "criteria": [ { "name": "Asks for an action" }, { "name": "Reports information" }, { "name": "Commits to an action" }, { "name": "Expresses a reaction" }, { "name": "Mixed or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_request_report_or_commitment": Question_Choice( instructions="Does the speaker ask for an action, report information, commit to an action, or express a reaction?", criteria=[ Criterion(name="Asks for an action"), Criterion(name="Reports information"), Criterion(name="Commits to an action"), Criterion(name="Expresses a reaction"), Criterion(name="Mixed or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_request_report_or_commitment: { type: "choice", instructions: "Does the speaker ask for an action, report information, commit to an action, or express a reaction?", criteria: [ { name: "Asks for an action" }, { name: "Reports information" }, { name: "Commits to an action" }, { name: "Expresses a reaction" }, { name: "Mixed or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Existing music in a submitted clip Is background music audible underneath the speech? Avoid unintentionally layering two music beds. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "existing_music_in_a_submitted_clip": { "type": "noul", "instructions": "Is background music audible underneath the speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "existing_music_in_a_submitted_clip": Question_Noul( instructions="Is background music audible underneath the speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { existing_music_in_a_submitted_clip: { type: "noul", instructions: "Is background music audible underneath the speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### An interjection in a podcast excerpt Does the second voice take over, or briefly acknowledge while the first speaker continues? Describe a conversational event before cutting an exchange into a short clip. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "an_interjection_in_a_podcast_excerpt": { "type": "choice", "instructions": "Does the second voice take over, or briefly acknowledge while the first speaker continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; the first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "an_interjection_in_a_podcast_excerpt": Question_Choice( instructions="Does the second voice take over, or briefly acknowledge while the first speaker continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; the first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { an_interjection_in_a_podcast_excerpt: { type: "choice", instructions: "Does the second voice take over, or briefly acknowledge while the first speaker continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; the first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Pace of a spoken explanation Is the speaking rate slow, moderate or fast? Describe how quickly a creator speaks in a short how-to clip. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Rate the selected passage'\''s pace separately from whether the instructions are correct, intelligible or easy to learn.", "questions": { "pace_of_a_spoken_explanation": { "type": "score", "instructions": "Is the speaking rate slow, moderate or fast?", "criteria": ["Slow", "Moderate", "Fast"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Rate the selected passage's pace separately from whether the instructions are correct, intelligible or easy to learn.", questions={ "pace_of_a_spoken_explanation": Question_Score( instructions="Is the speaking rate slow, moderate or fast?", criteria=["Slow", "Moderate", "Fast"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Rate the selected passage's pace separately from whether the instructions are correct, intelligible or easy to learn.", questions: { pace_of_a_spoken_explanation: { type: "score", instructions: "Is the speaking rate slow, moderate or fast?", criteria: ["Slow", "Moderate", "Fast"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Background sound in a difficult-to-hear interview How noticeable is the background sound, on a scale from very intrusive to not noticeable? Describe the interference without guessing what the speaker said through it. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "background_sound_in_a_difficult_to_hear": { "type": "score", "instructions": "How noticeable is the background sound, on a scale from very intrusive to not noticeable?", "criteria": ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "background_sound_in_a_difficult_to_hear": Question_Score( instructions="How noticeable is the background sound, on a scale from very intrusive to not noticeable?", criteria=["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { background_sound_in_a_difficult_to_hear: { type: "score", instructions: "How noticeable is the background sound, on a scale from very intrusive to not noticeable?", criteria: ["Not noticeable", "Slightly noticeable", "Noticeable but not intrusive", "Somewhat intrusive", "Very intrusive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Laughter omitted from an interview transcript Is laughter audible in this excerpt? Preserve a nonverbal event in the text without interpreting it as agreement. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "laughter_omitted_from_an_interview_transcript": { "type": "noul", "instructions": "Is laughter audible in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "laughter_omitted_from_an_interview_transcript": Question_Noul( instructions="Is laughter audible in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { laughter_omitted_from_an_interview_transcript: { type: "noul", instructions: "Is laughter audible in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether a recorded reply answers the same topic How directly does the creator's reply address the audience question "How did you fix the loose handle on this pan?" Separate an on-topic response clip from one that addresses something else. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Supplied audience question: \"How did you fix the loose handle on this pan?\" Judge relevance to that question, not whether the repair advice is safe, true or complete.", "questions": { "whether_a_recorded_reply_answers_the_same_topic": { "type": "score", "instructions": "How directly does the creator'\''s reply address the audience question \"How did you fix the loose handle on this pan?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Supplied audience question: \"How did you fix the loose handle on this pan?\" Judge relevance to that question, not whether the repair advice is safe, true or complete.", questions={ "whether_a_recorded_reply_answers_the_same_topic": Question_Score( instructions="How directly does the creator's reply address the audience question \"How did you fix the loose handle on this pan?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Supplied audience question: \"How did you fix the loose handle on this pan?\" Judge relevance to that question, not whether the repair advice is safe, true or complete.", questions: { whether_a_recorded_reply_answers_the_same_topic: { type: "score", instructions: "How directly does the creator's reply address the audience question \"How did you fix the loose handle on this pan?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### One voice or a conversation? How many distinct speaking voices are audible? Help distinguish a solo quotation from a discussion clip. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Count distinct voices, not turns.", "questions": { "one_voice_or_a_conversation": { "type": "choice", "instructions": "How many distinct speaking voices are audible?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="Count distinct voices, not turns.", questions={ "one_voice_or_a_conversation": Question_Choice( instructions="How many distinct speaking voices are audible?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Count distinct voices, not turns.", questions: { one_voice_or_a_conversation: { type: "choice", instructions: "How many distinct speaking voices are audible?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Which series was requested? Which listed series does the speaker ask to hear about? Organize explicit content requests without inferring interests from someone's voice. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The supplied series menu is Garden Notes, City Walks, Kitchen Trials and Weekend Repairs; classify only the named request. Choose \"None, several or unclear\" when no listed series, several series or an unclear title is requested.", "questions": { "which_series_was_requested": { "type": "choice", "instructions": "Which listed series does the speaker ask to hear about?", "criteria": [ { "name": "Garden Notes" }, { "name": "City Walks" }, { "name": "Kitchen Trials" }, { "name": "Weekend Repairs" }, { "name": "None, several or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The supplied series menu is Garden Notes, City Walks, Kitchen Trials and Weekend Repairs; classify only the named request. Choose \"None, several or unclear\" when no listed series, several series or an unclear title is requested.", questions={ "which_series_was_requested": Question_Choice( instructions="Which listed series does the speaker ask to hear about?", criteria=[ Criterion(name="Garden Notes"), Criterion(name="City Walks"), Criterion(name="Kitchen Trials"), Criterion(name="Weekend Repairs"), Criterion(name="None, several or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The supplied series menu is Garden Notes, City Walks, Kitchen Trials and Weekend Repairs; classify only the named request. Choose \"None, several or unclear\" when no listed series, several series or an unclear title is requested.", questions: { which_series_was_requested: { type: "choice", instructions: "Which listed series does the speaker ask to hear about?", criteria: [ { name: "Garden Notes" }, { name: "City Walks" }, { name: "Kitchen Trials" }, { name: "Weekend Repairs" }, { name: "None, several or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Routing an explicit audience request Which listed purpose does this audio message state? Sort a spoken request by the action explicitly requested, without inferring the listener's interests. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "routing_an_explicit_audience_request": { "type": "choice", "instructions": "Which listed purpose does this audio message state?", "criteria": [ { "name": "Explain how something works" }, { "name": "Suggest a topic" }, { "name": "Invite a collaboration" }, { "name": "Correct a stated detail" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "routing_an_explicit_audience_request": Question_Choice( instructions="Which listed purpose does this audio message state?", criteria=[ Criterion(name="Explain how something works"), Criterion(name="Suggest a topic"), Criterion(name="Invite a collaboration"), Criterion(name="Correct a stated detail"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { routing_an_explicit_audience_request: { type: "choice", instructions: "Which listed purpose does this audio message state?", criteria: [ { name: "Explain how something works" }, { name: "Suggest a topic" }, { name: "Invite a collaboration" }, { name: "Correct a stated detail" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Locating a word needed for a caption check Find the first occurrence of "refund" in this recording. Find a spoken word for replay while checking a caption. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the excerpt.", "questions": { "locating_a_word_needed_for_a_caption_check": { "type": "span", "instructions": "Find the first occurrence of \"refund\" in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the excerpt.", questions={ "locating_a_word_needed_for_a_caption_check": Question_Span( instructions="Find the first occurrence of \"refund\" in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the excerpt.", questions: { locating_a_word_needed_for_a_caption_check: { type: "span", instructions: "Find the first occurrence of \"refund\" in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### How much of a hard-to-hear passage is understandable How much of the speech in this short excerpt can a listener understand? Describe how much is understandable before treating a guessed phrase as a quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "how_much_of_a_hard_to_hear_passage_is": { "type": "score", "instructions": "How much of the speech in this short excerpt can a listener understand?", "criteria": ["Almost none", "Some", "Most", "All"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "how_much_of_a_hard_to_hear_passage_is": Question_Score( instructions="How much of the speech in this short excerpt can a listener understand?", criteria=["Almost none", "Some", "Most", "All"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { how_much_of_a_hard_to_hear_passage_is: { type: "score", instructions: "How much of the speech in this short excerpt can a listener understand?", criteria: ["Almost none", "Some", "Most", "All"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### The opinion expressed in a review How positive or negative is the opinion expressed in this clip? Index the expressed opinion, separately from the reviewer's private feelings or future purchases. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "the_opinion_expressed_in_a_review": { "type": "score", "instructions": "How positive or negative is the opinion expressed in this clip?", "criteria": ["Very negative", "Negative", "Neutral", "Positive", "Very positive"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( questions={ "the_opinion_expressed_in_a_review": Question_Score( instructions="How positive or negative is the opinion expressed in this clip?", criteria=["Very negative", "Negative", "Neutral", "Positive", "Very positive"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { the_opinion_expressed_in_a_review: { type: "score", instructions: "How positive or negative is the opinion expressed in this clip?", criteria: ["Very negative", "Negative", "Neutral", "Positive", "Very positive"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding a reaction moment Find the first audible laughter in this interview excerpt. Suggest a replay interval for an editor to inspect. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Return a candidate interval relative to the supplied excerpt.", "questions": { "finding_a_reaction_moment": { "type": "span", "instructions": "Find the first audible laughter in this interview excerpt." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Return a candidate interval relative to the supplied excerpt.", questions={ "finding_a_reaction_moment": Question_Span( instructions="Find the first audible laughter in this interview excerpt.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Return a candidate interval relative to the supplied excerpt.", questions: { finding_a_reaction_moment: { type: "span", instructions: "Find the first audible laughter in this interview excerpt.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a quote used for a caption Which supplied word carries the strongest emphasis? Keep the stressed word visible when deciding how to present a spoken quotation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The creator says, \"Try it before buying.\" Identify the actual stress rather than deciding whether the statement is sarcastic or sincere.", "questions": { "emphasis_in_a_quote_used_for_a_caption": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Try" }, { "name": "It" }, { "name": "Before" }, { "name": "Buying" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The creator says, \"Try it before buying.\" Identify the actual stress rather than deciding whether the statement is sarcastic or sincere.", questions={ "emphasis_in_a_quote_used_for_a_caption": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Try"), Criterion(name="It"), Criterion(name="Before"), Criterion(name="Buying"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The creator says, \"Try it before buying.\" Identify the actual stress rather than deciding whether the statement is sarcastic or sincere.", questions: { emphasis_in_a_quote_used_for_a_caption: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Try" }, { name: "It" }, { name: "Before" }, { name: "Buying" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Visit time read back Are the visit date and time read back correctly? Put the booked time in `context`, such as "Tuesday, between two and four in the afternoon". The answer checks the readout, not the booking. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Booked visit: Tuesday, between two and four in the afternoon", "questions": { "visit_time_read_back": { "type": "noul", "instructions": "Are the visit date and time read back correctly?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( context="Booked visit: Tuesday, between two and four in the afternoon", questions={ "visit_time_read_back": Question_Noul( instructions="Are the visit date and time read back correctly?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Booked visit: Tuesday, between two and four in the afternoon", questions: { visit_time_read_back: { type: "noul", instructions: "Are the visit date and time read back correctly?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Utility request Which listed request is the caller making? List requests such as changing a visit, asking about a bill and submitting a meter reading as options. The answer is the stated request, not an inferred need. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "utility_request": { "type": "choice", "instructions": "Which listed request is the caller making?", "criteria": [ { "name": "Change a visit" }, { "name": "Ask about a bill" }, { "name": "Submit a meter reading" }, { "name": "Ask about opening hours" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "utility_request": Question_Choice( instructions="Which listed request is the caller making?", criteria=[ Criterion(name="Change a visit"), Criterion(name="Ask about a bill"), Criterion(name="Submit a meter reading"), Criterion(name="Ask about opening hours"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { utility_request: { type: "choice", instructions: "Which listed request is the caller making?", criteria: [ { name: "Change a visit" }, { name: "Ask about a bill" }, { name: "Submit a meter reading" }, { name: "Ask about opening hours" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Overlap on an address Do two people speak at the same time in this excerpt? Send the part where the service address is said. A person still confirms any unclear details. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "overlap_on_an_address": { "type": "noul", "instructions": "Do two people speak at the same time in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "overlap_on_an_address": Question_Noul( instructions="Do two people speak at the same time in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { overlap_on_an_address: { type: "noul", instructions: "Do two people speak at the same time in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Distortion on a utility call Does the speech sound distorted or clipped? The answer says whether distortion is heard, not whether the visit details are correct. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "distortion_on_a_utility_call": { "type": "noul", "instructions": "Does the speech sound distorted or clipped?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "distortion_on_a_utility_call": Question_Noul( instructions="Does the speech sound distorted or clipped?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { distortion_on_a_utility_call: { type: "noul", instructions: "Does the speech sound distorted or clipped?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Clarify a repeated meter-reading instruction Does "Send a reading" sound like a question about the instruction or a restatement of it? Identify a questioning repetition that may need a clearer explanation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The agent says, \"Please send a meter reading.\" The customer replies, \"Send a reading.\" Listen to the customer'\''s delivery.", "questions": { "clarify_a_repeated_meter_reading_instruction": { "type": "choice", "instructions": "Does \"Send a reading\" sound like a question about the instruction or a restatement of it?", "criteria": [ { "name": "Questions the instruction" }, { "name": "Restates the instruction" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The agent says, \"Please send a meter reading.\" The customer replies, \"Send a reading.\" Listen to the customer's delivery.", questions={ "clarify_a_repeated_meter_reading_instruction": Question_Choice( instructions="Does \"Send a reading\" sound like a question about the instruction or a restatement of it?", criteria=[ Criterion(name="Questions the instruction"), Criterion(name="Restates the instruction"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The agent says, \"Please send a meter reading.\" The customer replies, \"Send a reading.\" Listen to the customer's delivery.", questions: { clarify_a_repeated_meter_reading_instruction: { type: "choice", instructions: "Does \"Send a reading\" sound like a question about the instruction or a restatement of it?", criteria: [ { name: "Questions the instruction" }, { name: "Restates the instruction" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Noise underneath a customer's service report Which listed sound is audible underneath the caller's voice? Give a concrete audio description rather than infer conditions at the property. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "noise_underneath_a_customers_service_report": { "type": "choice", "instructions": "Which listed sound is audible underneath the caller'\''s voice?", "criteria": [ { "name": "Hiss or static" }, { "name": "Low hum" }, { "name": "Other people talking" }, { "name": "Music" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "noise_underneath_a_customers_service_report": Question_Choice( instructions="Which listed sound is audible underneath the caller's voice?", criteria=[ Criterion(name="Hiss or static"), Criterion(name="Low hum"), Criterion(name="Other people talking"), Criterion(name="Music"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { noise_underneath_a_customers_service_report: { type: "choice", instructions: "Which listed sound is audible underneath the caller's voice?", criteria: [ { name: "Hiss or static" }, { name: "Low hum" }, { name: "Other people talking" }, { name: "Music" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### A coughing sound during an outage update Is coughing audible in this recording? Describe an audible interruption in a service announcement, not a health condition. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "a_coughing_sound_during_an_outage_update": { "type": "noul", "instructions": "Is coughing audible in this recording?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "a_coughing_sound_during_an_outage_update": Question_Noul( instructions="Is coughing audible in this recording?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { a_coughing_sound_during_an_outage_update: { type: "noul", instructions: "Is coughing audible in this recording?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Several voices on the customer side of a service call How many distinct speakers are audible in this excerpt? Count the voices heard before a person confirms who is speaking. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "several_voices_on_the_customer_side_of_a_service": { "type": "choice", "instructions": "How many distinct speakers are audible in this excerpt?", "criteria": [ { "name": "1" }, { "name": "2" }, { "name": "3" }, { "name": "4 or more" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "several_voices_on_the_customer_side_of_a_service": Question_Choice( instructions="How many distinct speakers are audible in this excerpt?", criteria=[ Criterion(name="1"), Criterion(name="2"), Criterion(name="3"), Criterion(name="4 or more"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { several_voices_on_the_customer_side_of_a_service: { type: "choice", instructions: "How many distinct speakers are audible in this excerpt?", criteria: [ { name: "1" }, { name: "2" }, { name: "3" }, { name: "4 or more" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Voice continuity across changing outage announcements How likely is the new generated update to be in the same voice as the existing introduction? Check whether a new generated update sounds consistent with the phone line's existing voice. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The clip plays the introduction, the update and the introduction again. Judge perceived voice continuity, not whether the update'\''s factual content is correct.", "questions": { "voice_continuity_across_changing_outage": { "type": "score", "instructions": "How likely is the new generated update to be in the same voice as the existing introduction?", "criteria": ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="The clip plays the introduction, the update and the introduction again. Judge perceived voice continuity, not whether the update's factual content is correct.", questions={ "voice_continuity_across_changing_outage": Question_Score( instructions="How likely is the new generated update to be in the same voice as the existing introduction?", criteria=["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The clip plays the introduction, the update and the introduction again. Judge perceived voice continuity, not whether the update's factual content is correct.", questions: { voice_continuity_across_changing_outage: { type: "score", instructions: "How likely is the new generated update to be in the same voice as the existing introduction?", criteria: ["Definitely different", "Probably different", "Unsure", "Probably the same", "Definitely the same"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Acknowledgment or taking over a service report Does the second speaker take over the turn, or briefly acknowledge while the first continues? Describe a selected turn-taking event in a customer–utility conversation. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "acknowledgment_or_taking_over_a_service_report": { "type": "choice", "instructions": "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", "criteria": [ { "name": "Takes over the turn" }, { "name": "Brief acknowledgment; first speaker continues" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "acknowledgment_or_taking_over_a_service_report": Question_Choice( instructions="Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria=[ Criterion(name="Takes over the turn"), Criterion(name="Brief acknowledgment; first speaker continues"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { acknowledgment_or_taking_over_a_service_report: { type: "choice", instructions: "Does the second speaker take over the turn, or briefly acknowledge while the first continues?", criteria: [ { name: "Takes over the turn" }, { name: "Brief acknowledgment; first speaker continues" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Music continuing after hold Is music audible underneath the agent's speech? Find a reproducible audio example for a service-platform issue, without identifying its cause. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "music_continuing_after_hold": { "type": "noul", "instructions": "Is music audible underneath the agent'\''s speech?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "music_continuing_after_hold": Question_Noul( instructions="Is music audible underneath the agent's speech?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { music_continuing_after_hold: { type: "noul", instructions: "Is music audible underneath the agent's speech?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Whether the reply addresses the meter-reading question How directly does the reply address the question "How do I submit a meter reading?" Distinguish relevance from whether a reading was actually received. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Judge relevance, not the reading'\''s correctness, the bill or successful submission.", "questions": { "whether_the_reply_addresses_the_meter_reading": { "type": "score", "instructions": "How directly does the reply address the question \"How do I submit a meter reading?\"", "criteria": ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Score, ) client = DecisionsClient() request = DecisionsRequest( context="Judge relevance, not the reading's correctness, the bill or successful submission.", questions={ "whether_the_reply_addresses_the_meter_reading": Question_Score( instructions="How directly does the reply address the question \"How do I submit a meter reading?\"", criteria=["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Judge relevance, not the reading's correctness, the bill or successful submission.", questions: { whether_the_reply_addresses_the_meter_reading: { type: "score", instructions: "How directly does the reply address the question \"How do I submit a meter reading?\"", criteria: ["Off-topic", "Mostly off-topic", "Partly relevant", "Mostly relevant", "Directly relevant"], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emphasis in a question about a visit Which supplied word carries the strongest emphasis? Identify what is stressed before a person clarifies the customer's question. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The customer asks, \"Is the visit this Tuesday?\" Locate stress rather than confirming the date or explaining the customer'\''s intention.", "questions": { "emphasis_in_a_question_about_a_visit": { "type": "choice", "instructions": "Which supplied word carries the strongest emphasis?", "criteria": [ { "name": "Is" }, { "name": "The" }, { "name": "Visit" }, { "name": "This" }, { "name": "Tuesday" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The customer asks, \"Is the visit this Tuesday?\" Locate stress rather than confirming the date or explaining the customer's intention.", questions={ "emphasis_in_a_question_about_a_visit": Question_Choice( instructions="Which supplied word carries the strongest emphasis?", criteria=[ Criterion(name="Is"), Criterion(name="The"), Criterion(name="Visit"), Criterion(name="This"), Criterion(name="Tuesday"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The customer asks, \"Is the visit this Tuesday?\" Locate stress rather than confirming the date or explaining the customer's intention.", questions: { emphasis_in_a_question_about_a_visit: { type: "choice", instructions: "Which supplied word carries the strongest emphasis?", criteria: [ { name: "Is" }, { name: "The" }, { name: "Visit" }, { name: "This" }, { name: "Tuesday" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Choosing a rescheduling function Which supplied tool should the assistant select first? Choose the function matching the explicit request for availability, rather than prematurely changing a booking. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The visit is already identified, scheduled and changeable. Tools: list_available_visit_slots returns available times; get_booking_status returns existing status; confirm_visit_change commits a chosen slot; contact_scheduler requests human help. Choose the first function without executing it.", "questions": { "choosing_a_rescheduling_function": { "type": "choice", "instructions": "Which supplied tool should the assistant select first?", "criteria": [ { "name": "list_available_visit_slots" }, { "name": "get_booking_status" }, { "name": "confirm_visit_change" }, { "name": "contact_scheduler" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The visit is already identified, scheduled and changeable. Tools: list_available_visit_slots returns available times; get_booking_status returns existing status; confirm_visit_change commits a chosen slot; contact_scheduler requests human help. Choose the first function without executing it.", questions={ "choosing_a_rescheduling_function": Question_Choice( instructions="Which supplied tool should the assistant select first?", criteria=[ Criterion(name="list_available_visit_slots"), Criterion(name="get_booking_status"), Criterion(name="confirm_visit_change"), Criterion(name="contact_scheduler"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The visit is already identified, scheduled and changeable. Tools: list_available_visit_slots returns available times; get_booking_status returns existing status; confirm_visit_change commits a chosen slot; contact_scheduler requests human help. Choose the first function without executing it.", questions: { choosing_a_rescheduling_function: { type: "choice", instructions: "Which supplied tool should the assistant select first?", criteria: [ { name: "list_available_visit_slots" }, { name: "get_booking_status" }, { name: "confirm_visit_change" }, { name: "contact_scheduler" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Language support for a utility-service call Which listed language is spoken in this excerpt? Identify a likely language before offering communication assistance. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "The call is known to use one of the five listed languages.", "questions": { "language_support_for_a_utility_service_call": { "type": "choice", "instructions": "Which listed language is spoken in this excerpt?", "criteria": [ { "name": "English" }, { "name": "Japanese" }, { "name": "Arabic" }, { "name": "French" }, { "name": "Russian" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( context="The call is known to use one of the five listed languages.", questions={ "language_support_for_a_utility_service_call": Question_Choice( instructions="Which listed language is spoken in this excerpt?", criteria=[ Criterion(name="English"), Criterion(name="Japanese"), Criterion(name="Arabic"), Criterion(name="French"), Criterion(name="Russian"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "The call is known to use one of the five listed languages.", questions: { language_support_for_a_utility_service_call: { type: "choice", instructions: "Which listed language is spoken in this excerpt?", criteria: [ { name: "English" }, { name: "Japanese" }, { name: "Arabic" }, { name: "French" }, { name: "Russian" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Replaying a stated visit date Find the first occurrence of "Tuesday" in this recording. Find the date statement for human replay instead of relying only on a tentative transcript. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Times are relative to the supplied one-minute excerpt.", "questions": { "replaying_a_stated_visit_date": { "type": "span", "instructions": "Find the first occurrence of \"Tuesday\" in this recording." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Times are relative to the supplied one-minute excerpt.", questions={ "replaying_a_stated_visit_date": Question_Span( instructions="Find the first occurrence of \"Tuesday\" in this recording.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Times are relative to the supplied one-minute excerpt.", questions: { replaying_a_stated_visit_date: { type: "span", instructions: "Find the first occurrence of \"Tuesday\" in this recording.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Finding where a visit arrangement was discussed Find where the engineer visit is discussed. Offer a candidate passage to replay when checking what was said about the visit. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "context": "Return candidate intervals relative to the supplied excerpt.", "questions": { "finding_where_a_visit_arrangement_was_discussed": { "type": "span", "instructions": "Find where the engineer visit is discussed." } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Span, ) client = DecisionsClient() request = DecisionsRequest( context="Return candidate intervals relative to the supplied excerpt.", questions={ "finding_where_a_visit_arrangement_was_discussed": Question_Span( instructions="Find where the engineer visit is discussed.", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { context: "Return candidate intervals relative to the supplied excerpt.", questions: { finding_where_a_visit_arrangement_was_discussed: { type: "span", instructions: "Find where the engineer visit is discussed.", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Repeated words in a customer's service report Is a word said twice in a row in this excerpt? Check for an audible repetition when preparing a verbatim transcript, without interpreting the customer's state. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "repeated_words_in_a_customers_service_report": { "type": "noul", "instructions": "Is a word said twice in a row in this excerpt?" } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( DecisionsClient, DecisionsRequest, Question_Noul, ) client = DecisionsClient() request = DecisionsRequest( questions={ "repeated_words_in_a_customers_service_report": Question_Noul( instructions="Is a word said twice in a row in this excerpt?", ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { repeated_words_in_a_customers_service_report: { type: "noul", instructions: "Is a word said twice in a row in this excerpt?", }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` #### Emotion expressed during a service complaint Which listed emotion does the customer's voice express? Describe vocal expression without using it to prioritize an outage or account decision. #### cURL ```bash curl https://api.cloud.hume.ai/v0/decisions/file \ -H "X-Hume-Api-Key: $HUME_API_KEY" \ -F 'request={ "questions": { "emotion_expressed_during_a_service_complaint_2": { "type": "choice", "instructions": "Which listed emotion does the customer'\''s voice express?", "criteria": [ { "name": "Sad" }, { "name": "Fearful" }, { "name": "Angry" }, { "name": "Happy" }, { "name": "Neutral" }, { "name": "None of these or unclear" } ] } } };type=application/json' \ -F file=@recording.wav ``` #### Python ```python from hume_audio_decisions import ( Criterion, DecisionsClient, DecisionsRequest, Question_Choice, ) client = DecisionsClient() request = DecisionsRequest( questions={ "emotion_expressed_during_a_service_complaint_2": Question_Choice( instructions="Which listed emotion does the customer's voice express?", criteria=[ Criterion(name="Sad"), Criterion(name="Fearful"), Criterion(name="Angry"), Criterion(name="Happy"), Criterion(name="Neutral"), Criterion(name="None of these or unclear"), ], ), }, ) with open("recording.wav", "rb") as audio: response = client.decisions.create( file=("recording.wav", audio, "audio/wav"), request=request, ) print(response.model_dump_json(indent=2)) ``` #### TypeScript ```typescript import { DecisionsClient } from "@humeai/audio-decisions"; const client = new DecisionsClient(); const response = await client.decisions.create({ file: { path: "recording.wav", contentType: "audio/wav", }, request: { questions: { emotion_expressed_during_a_service_complaint_2: { type: "choice", instructions: "Which listed emotion does the customer's voice express?", criteria: [ { name: "Sad" }, { name: "Fearful" }, { name: "Angry" }, { name: "Happy" }, { name: "Neutral" }, { name: "None of these or unclear" }, ], }, }, }, }); console.log(JSON.stringify(response, null, 2)); ``` ## Next steps #### [Writing questions](/audio-decisions/docs/writing-questions) Learn how to write questions that get useful answers, and which questions to avoid.