Private audio transcription

Bash, curl, jq and Python 3; an existing workspace API key, an operator-issued noncash development grant and a supported private WAV are required. Set MODELUSE_TOKEN and MODELUSE_WAV locally. Never put them in a public URL or log.

This example uses the same pipeline, recipe, task reference and service as the form. It saves only private run state and the result on your own machine. Reuse its directory and key to recover the same request; do not repeat an uncertain upload.

set -euo pipefail
: "${MODELUSE_TOKEN:?Set your existing workspace API key}"
CORE="${MODELUSE_CORE:-https://core.modeluse.com}"
WAV="${MODELUSE_WAV:-./short-clip.wav}"
RUN_DIR="${MODELUSE_RUN_DIR:-./modeluse-run}"
RECIPE_ID='whisper-tiny-cpu-v1:openai--whisper-tiny:169d4a4341b33bc18d8881c4b69c2e104e1cc0af'
umask 077
mkdir -p "$RUN_DIR"
PIPELINE_ID='whisper-transcription-v1'
# Resolve the exact enabled live pipeline before sending private audio.
curl --fail --silent --show-error --max-time 20 "$CORE/v1/pipelines/$PIPELINE_ID" > "$RUN_DIR/pipeline.json"
curl --fail --silent --show-error --max-time 20 "$CORE/v1/pipelines" > "$RUN_DIR/pipelines.json"
curl --fail --silent --show-error --max-time 20 "$CORE/v1/models" > "$RUN_DIR/models.json"
jq -e --arg recipe "$RECIPE_ID" --arg pipeline "$PIPELINE_ID" \
  --slurpfile list "$RUN_DIR/pipelines.json" --slurpfile models "$RUN_DIR/models.json" '
  . as $p | ($list[0].items | map(select(.id==$pipeline)) | first)==$p and
  ($models[0].items | any(.id=="openai--whisper-tiny" and
    (.versions | any(.revision=="169d4a4341b33bc18d8881c4b69c2e104e1cc0af" and
      (.recipes | any(.id==$recipe and .adapter=="whisper-tiny-cpu-v1" and
        .available==true and .runnable==true and .meter=="noncash-dev-seconds-v1" and
        .limits=={device:"cpu",format:"pcm_wav",max_seconds:30})))))) and
  .id==$pipeline and .recipe_id==$recipe and .capability=="transcription" and
  .availability.available==true and .availability.preview==true and .availability.status=="qualified_preview" and
  .input_contract.content_type=="audio/wav" and .input_contract.format=="pcm_wav" and
  .input_contract.sample_width_bits==16 and .input_contract.channels==[1,2] and
  .input_contract.sample_rate_hz=={min:8000,max:48000} and
  .input_contract.min_seconds==0.1 and .input_contract.max_seconds==30 and
  .input_contract.max_bytes==6291456 and .input_contract.max_batch_size==1 and
  .admission_contract.endpoint=="POST /v1/jobs" and
  .admission_contract.meter=="noncash-dev-seconds-v1" and .admission_contract.payments_enabled==false and
  .admission_contract.external_budget_usd==0 and .result_contract.schema=="modeluse-transcription-v1" and
  .result_contract.quality_benchmark==false and .execution_contract.device=="cpu" and
  .qualification.model_revision=="169d4a4341b33bc18d8881c4b69c2e104e1cc0af" and
  .qualification.license=="apache-2.0" and
  .qualification.weight_sha256=="7ebd0e69e78190ffe1438491fa05cc1f5c1aa3a4c4db3bc1723adbb551ea2395"
  
' "$RUN_DIR/pipeline.json" >/dev/null

curl --fail --silent --show-error --max-time 20 -H "Authorization: Bearer $MODELUSE_TOKEN" \
  "$CORE/v1/credits" > "$RUN_DIR/credits.json"
jq -e '.meter_version=="noncash-dev-seconds-v1" and .payments_enabled==false' "$RUN_DIR/credits.json" >/dev/null

# Upload once. Stop after an uncertain upload; do not silently repeat it.
if [ ! -f "$RUN_DIR/input.json" ]; then
  jq -e ' .available>0 ' "$RUN_DIR/credits.json" >/dev/null || { echo 'No development audio units available. An existing operator-issued grant is required; sign-in and funding grant no units.' >&2; exit 1; }
  [ ! -e "$RUN_DIR/upload.started" ] || { echo 'Inspect the uncertain upload before retrying.' >&2; exit 1; }
  : > "$RUN_DIR/upload.started"
  curl --fail --silent --show-error --max-time 30 -X POST "$CORE/v1/inputs" \
    -H "Authorization: Bearer $MODELUSE_TOKEN" -H 'Content-Type: audio/wav' \
    --data-binary "@$WAV" > "$RUN_DIR/input.tmp"
  mv "$RUN_DIR/input.tmp" "$RUN_DIR/input.json"
fi
INPUT_ID=$(jq -er '.id' "$RUN_DIR/input.json")
curl --fail --silent --show-error --max-time 30 -H "Authorization: Bearer $MODELUSE_TOKEN" \
  "$CORE/v1/inputs/$INPUT_ID/quote" > "$RUN_DIR/quote.json"
jq -e --arg recipe "$RECIPE_ID" --arg input "$INPUT_ID"  \
  '.recipe_id==$recipe and .input_id==$input and .meter_version=="noncash-dev-seconds-v1" and .payments_enabled==false and
   (.duration_seconds|type)=="number" and .duration_seconds>=0.1 and .duration_seconds<=30 and
   (.units|type)=="number" and .units==(.duration_seconds|ceil) ' \
  "$RUN_DIR/quote.json" >/dev/null

if [ ! -f "$RUN_DIR/request.json" ]; then
  jq -e --slurpfile credits "$RUN_DIR/credits.json" \
  '.units <= $credits[0].available' "$RUN_DIR/quote.json" >/dev/null || { echo 'This quote exceeds the available development audio units. No job was submitted.' >&2; exit 1; }
fi
cat "$RUN_DIR/quote.json"

# Keep this exact body and key for retries. Use a new directory for a deliberate new run.
if [ ! -f "$RUN_DIR/request.json" ]; then
  jq -nc --arg recipe "$RECIPE_ID" --arg input "$INPUT_ID" \
    --arg reference '' --arg service 'interactive' --arg pipeline "$PIPELINE_ID" \
    '{pipeline_id:$pipeline,recipe_id:$recipe,input_id:$input,caller_reference:$reference,service:$service}' > "$RUN_DIR/request.json"
fi
# Never turn an older model-only retry into a pipeline request (or the reverse).
jq -e --arg recipe "$RECIPE_ID" --arg input "$INPUT_ID" --arg pipeline "$PIPELINE_ID" \
  '.recipe_id==$recipe and .input_id==$input and (.pipeline_id // "")==$pipeline' "$RUN_DIR/request.json" >/dev/null
[ -s "$RUN_DIR/request-key" ] || python3 -c 'import uuid; print(uuid.uuid4())' > "$RUN_DIR/request-key"
REQUEST_KEY=$(cat "$RUN_DIR/request-key")
curl --fail --silent --show-error --max-time 30 -X POST "$CORE/v1/jobs" \
  -H "Authorization: Bearer $MODELUSE_TOKEN" -H 'Content-Type: application/json' \
  -H "Idempotency-Key: $REQUEST_KEY" --data-binary "@$RUN_DIR/request.json" > "$RUN_DIR/job.json"
JOB_ID=$(jq -er '.id' "$RUN_DIR/job.json")
jq -e --arg pipeline "$PIPELINE_ID" ' .pipeline_id==$pipeline and .policy.pipeline_id==$pipeline ' "$RUN_DIR/job.json" >/dev/null
# Bounded readback. A timeout leaves the durable job running: rerun to recover.
for poll in $(seq 1 150); do
  curl --fail --silent --show-error --max-time 30 -H "Authorization: Bearer $MODELUSE_TOKEN" \
    "$CORE/v1/jobs/$JOB_ID" > "$RUN_DIR/job.json"
  STATUS=$(jq -er '.status' "$RUN_DIR/job.json")
  case "$STATUS" in
    completed) break ;;
    failed|cancelled) echo "Job is $STATUS; inspect its private receipt." >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
[ "$STATUS" = completed ] || { echo "Job remains $STATUS; recover the same directory or cancel the job explicitly." >&2; exit 1; }

ARTIFACT_ID=$(jq -er '.artifact_id' "$RUN_DIR/job.json")
curl --fail --silent --show-error --max-time 30 -H "Authorization: Bearer $MODELUSE_TOKEN" \
  "$CORE/v1/artifacts/$ARTIFACT_ID" > "$RUN_DIR/result.tmp"
jq -e --arg job "$JOB_ID" --arg pipeline "$PIPELINE_ID" '.job_id==$job and .pipeline_id==$pipeline' "$RUN_DIR/result.tmp" >/dev/null
mv "$RUN_DIR/result.tmp" "$RUN_DIR/result.json"
printf '%s\n' "Private JSON saved: $RUN_DIR/result.json"

To cancel accepted work, use its saved job ID with POST /v1/jobs/{job_id}/cancel and the same existing credential. Leaving this page or stopping the script does not cancel a job.