parts = MinutesService.splitForSpeech(text, MinutesService.TTS_MAX_CHARS);
+ try (Transcript t = new Transcript("06b-speech-split.txt", "Splitting a long read-back at sentence ends")) {
+ t.line("text: %d characters, %d sentences", text.length(), 120);
+ for (int i = 0; i < parts.size(); i++) {
+ String p = parts.get(i);
+ t.line("part %d: %4d characters, ends with \"%s\"", i, p.length(), p.substring(p.length() - 12));
+ }
+ }
+ assertThat(parts).allSatisfy(p -> assertThat(p.length()).isLessThanOrEqualTo(MinutesService.TTS_MAX_CHARS));
+ assertThat(String.join(" ", parts)).isEqualTo(text);
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/SummariseTest.java b/audio/src/test/java/com/ankurm/audio/SummariseTest.java
new file mode 100644
index 0000000..818f730
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/SummariseTest.java
@@ -0,0 +1,83 @@
+package com.ankurm.audio;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.ankurm.audio.support.MeetingFixture;
+import com.ankurm.audio.support.ScriptedChatModel;
+import com.ankurm.audio.support.Transcript;
+import org.junit.jupiter.api.Test;
+import org.springframework.ai.chat.client.ChatClient;
+import org.springframework.ai.chat.messages.Message;
+
+/** Structured output for action items. The chat model is a STUB that replays canned JSON; it is not a language model. */
+class SummariseTest {
+
+ private static final String GOOD = """
+ {"title":"Falcon weekly sync",
+ "decisions":["Ship version 2.4 on the fourteenth of November","The data pipeline migrates to the new cluster next sprint"],
+ "actionItems":[
+ {"owner":"Rahul","task":"Fix the login timeout bug","due":"before the release on the fourteenth of November"},
+ {"owner":"Priya","task":"Send the revised budget to finance","due":"Friday"},
+ {"owner":"Sana","task":"Open tickets for both export endpoint issues","due":"today"}]}""";
+
+ @Test
+ void promptAndParsedRecord() {
+ ScriptedChatModel model = new ScriptedChatModel(GOOD);
+ var service = new MinutesService(null, ChatClient.create(model), null, "gpt-transcribe", "gpt-4o-mini-tts");
+ String transcript = String.join(" ", MeetingFixture.SCRIPT);
+
+ Minutes m = service.summarise(transcript);
+
+ try (Transcript t = new Transcript("05-structured-output.txt", "entity(Minutes.class) against a STUB ChatModel")) {
+ t.line("messages sent to the model:");
+ for (Message msg : model.prompts().getFirst().getInstructions()) {
+ String text = msg.getText();
+ t.line(" [%s] %d chars", msg.getMessageType(), text.length());
+ }
+ String user = model.prompts().getFirst().getInstructions().stream()
+ .filter(x -> x.getMessageType().name().equals("USER")).findFirst().orElseThrow().getText();
+ int at = user.indexOf("Your response should be in JSON format.");
+ t.line("");
+ t.line("tail of the USER message (the format instructions Spring AI appended):");
+ t.line("%s", user.substring(at));
+ t.blank();
+ t.line("parsed: %s", m.title());
+ t.line(" decisions : %d", m.decisions().size());
+ m.actionItems().forEach(a -> t.line(" action item : %-6s | %s | due: %s", a.owner(), a.task(), a.due()));
+ t.blank();
+ t.line("spoken form:");
+ t.line(" %s", m.toSpokenText());
+ }
+ assertThat(m.actionItems()).hasSize(3);
+ assertThat(m.actionItems().getFirst().owner()).isEqualTo("Rahul");
+ }
+
+ @Test
+ void whatABadReplyLooksLike() {
+ try (Transcript t = new Transcript("05b-bad-replies.txt", "Three replies a model can give instead of clean JSON (STUB model)")) {
+ String[] replies = {
+ "Here are the minutes:\n```json\n" + GOOD + "\n```",
+ "{\"title\":\"Falcon weekly sync\",\"decisions\":[],\"actionItems\":[{\"owner\":\"Rahul\",\"task\":\"Fix it\",\"due\":null}]",
+ "I could not find any action items in this transcript."
+ };
+ String[] labels = { "wrapped in a markdown fence with a sentence before it", "truncated: closing brace missing", "prose instead of JSON" };
+ for (int i = 0; i < replies.length; i++) {
+ var service = new MinutesService(null, ChatClient.create(new ScriptedChatModel(replies[i])), null, "x", "y");
+ String outcome;
+ try {
+ Minutes m = service.summarise("anything");
+ outcome = "parsed: " + m.actionItems().size() + " action item(s), first due=" + m.actionItems().getFirst().due();
+ } catch (RuntimeException e) {
+ outcome = e.getClass().getSimpleName() + ": " + first(e.getMessage());
+ }
+ t.line("%-52s -> %s", labels[i], outcome);
+ }
+ }
+ }
+
+ private static String first(String s) {
+ if (s == null) return "(no message)";
+ String one = s.replace('\n', ' ');
+ return one.length() > 110 ? one.substring(0, 110) + "..." : one;
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/TranscribeTest.java b/audio/src/test/java/com/ankurm/audio/TranscribeTest.java
new file mode 100644
index 0000000..a516517
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/TranscribeTest.java
@@ -0,0 +1,68 @@
+package com.ankurm.audio;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.ankurm.audio.support.FakeAudioServer;
+import com.ankurm.audio.support.MeetingFixture;
+import com.ankurm.audio.support.Models;
+import com.ankurm.audio.support.Transcript;
+import org.junit.jupiter.api.Test;
+import org.springframework.ai.audio.transcription.AudioTranscriptionPrompt;
+import org.springframework.ai.audio.transcription.AudioTranscriptionResponse;
+import org.springframework.ai.openai.OpenAiAudioTranscriptionOptions;
+
+/** The smallest working call, and exactly what the real client puts on the wire. MOCK server. */
+class TranscribeTest {
+
+ @Test
+ void smallClip() throws Exception {
+ byte[] whole = MeetingFixture.wav();
+ Wav.Info info = Wav.parse(whole);
+ byte[] clip = Wav.slice(whole, info, 0, 60 * MeetingFixture.SAMPLE_RATE); // first 60 s: two sentences
+ try (FakeAudioServer server = new FakeAudioServer();
+ Transcript t = new Transcript("02-transcribe-small.txt",
+ "One 60-second clip (" + clip.length + " bytes WAV) through OpenAiAudioTranscriptionModel -- MOCK server")) {
+ for (String model : new String[] { "whisper-1", "gpt-transcribe" }) {
+ server.clear();
+ var m = Models.transcription(server.baseUrl(), model);
+
+ // The convenience method: text in, text out.
+ String text = m.transcribe(new NamedBytes(clip, "standup.wav"));
+ FakeAudioServer.Seen s = server.seen().getFirst();
+ t.line("model option: %s", model);
+ t.line(" request : POST %s (multipart, %d bytes)", s.path(), s.bodyBytes());
+ t.line(" fields : %s", s.fields());
+ t.line(" file part : name=%s type=%s bytes=%d", s.filename(), s.fileContentType(), s.fileBytes());
+ t.line(" transcribe(Resource) -> \"%s\"", text);
+
+ // The full form: options per call, and a response object.
+ AudioTranscriptionResponse r = m.call(new AudioTranscriptionPrompt(new NamedBytes(clip, "standup.wav"),
+ OpenAiAudioTranscriptionOptions.builder().model(model).language("en").prompt("Falcon weekly sync").build()));
+ FakeAudioServer.Seen s2 = server.seen().getLast();
+ t.line(" with language=en and prompt, fields now: %s", s2.fields());
+ t.line(" response metadata class: %s", r.getMetadata().getClass().getSimpleName());
+ t.blank();
+ assertThat(text).startsWith(MeetingFixture.SCRIPT.get(0)).contains(MeetingFixture.SCRIPT.get(1));
+ }
+ }
+ }
+
+ @Test
+ void filenameExtensionMatters() throws Exception {
+ byte[] whole = MeetingFixture.wav();
+ byte[] clip = Wav.slice(whole, Wav.parse(whole), 0, 20 * MeetingFixture.SAMPLE_RATE);
+ try (FakeAudioServer server = new FakeAudioServer();
+ Transcript t = new Transcript("02b-filename.txt", "The upload's file name decides whether it is accepted -- MOCK server")) {
+ var m = Models.transcription(server.baseUrl(), "gpt-transcribe", 0);
+ for (String name : new String[] { "standup.wav", "standup.flac", "standup" }) {
+ String outcome;
+ try {
+ outcome = "ok: " + m.transcribe(new NamedBytes(clip, name)).length() + " chars";
+ } catch (RuntimeException e) {
+ outcome = e.getClass().getSimpleName() + ": " + e.getMessage();
+ }
+ t.line("file name %-13s -> %s", name, outcome);
+ }
+ }
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/support/FakeAudioServer.java b/audio/src/test/java/com/ankurm/audio/support/FakeAudioServer.java
new file mode 100644
index 0000000..6dadd81
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/support/FakeAudioServer.java
@@ -0,0 +1,252 @@
+package com.ankurm.audio.support;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import com.ankurm.audio.Wav;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpServer;
+import tools.jackson.databind.JsonNode;
+import tools.jackson.databind.json.JsonMapper;
+
+/**
+ * A MOCK of two OpenAI endpoints, /v1/audio/transcriptions and /v1/audio/speech, on a local port.
+ * The real Spring AI model classes (and the OpenAI Java SDK underneath them) talk to it over HTTP.
+ *
+ * What is real: the requests. Everything the client sends is recorded here as it arrived.
+ *
What is NOT real: the "transcription". There is no speech recogniser. The server decodes the
+ * pitch of each tone in the synthetic recording ({@link MeetingFixture}) back into the scripted
+ * sentence, and answers "[inaudible]" for a tone cut short (the mock's rule, standing in for the
+ * accuracy loss the OpenAI guide describes when you split mid-sentence). The "speech" is a beep
+ * whose length follows the text length. Nothing here says anything about accuracy, latency or
+ * cost of a real model.
+ *
+ *
Mock rules taken from OpenAI's documentation: uploads over 25 MB are refused (413; this mock
+ * uses 25 x 1024 x 1024 bytes), only the documented input extensions are accepted, and speech
+ * input over 4096 characters is refused (400).
+ */
+public final class FakeAudioServer implements AutoCloseable {
+
+ public static final long UPLOAD_LIMIT = 25L * 1024 * 1024;
+ private static final List EXTENSIONS = List.of("mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm");
+ private static final JsonMapper JSON = JsonMapper.builder().build();
+
+ /** One recorded request. */
+ public record Seen(String path, String contentType, long bodyBytes, Map fields,
+ String filename, String fileContentType, int fileBytes, String json) {}
+
+ private final HttpServer server;
+ private final List seen = new CopyOnWriteArrayList<>();
+ private final AtomicInteger failuresLeft = new AtomicInteger();
+ private volatile int failureStatus;
+
+ public FakeAudioServer() throws IOException {
+ server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
+ server.createContext("/v1/audio/transcriptions", this::transcriptions);
+ server.createContext("/v1/audio/speech", this::speech);
+ server.start();
+ }
+
+ /** The base URL to give to Spring AI's {@code baseUrl(...)} option (the SDK appends /audio/...). */
+ public String baseUrl() {
+ return "http://127.0.0.1:" + server.getAddress().getPort() + "/v1";
+ }
+
+ public List seen() { return seen; }
+
+ public void clear() { seen.clear(); }
+
+ /** The next {@code times} requests fail with {@code status} before normal service resumes. */
+ public void failNext(int times, int status) {
+ failureStatus = status;
+ failuresLeft.set(times);
+ }
+
+ @Override
+ public void close() { server.stop(0); }
+
+ // ---------------------------------------------------------------- transcriptions
+
+ private void transcriptions(HttpExchange ex) throws IOException {
+ byte[] body = ex.getRequestBody().readAllBytes();
+ String ct = ex.getRequestHeaders().getFirst("Content-Type");
+ Multipart mp = Multipart.parse(body, ct);
+ seen.add(new Seen("/v1/audio/transcriptions", ct, body.length, mp.fields, mp.filename, mp.fileType,
+ mp.file == null ? 0 : mp.file.length, null));
+ if (failuresLeft.getAndUpdate(n -> Math.max(0, n - 1)) > 0) {
+ reply(ex, failureStatus, "application/json", error("mock: simulated failure " + failureStatus, "server_error"));
+ return;
+ }
+ if (body.length > UPLOAD_LIMIT) {
+ reply(ex, 413, "application/json", error("mock: Maximum content size limit (" + UPLOAD_LIMIT
+ + ") exceeded (" + body.length + " bytes read)", "invalid_request_error"));
+ return;
+ }
+ String ext = mp.filename == null || !mp.filename.contains(".") ? ""
+ : mp.filename.substring(mp.filename.lastIndexOf('.') + 1).toLowerCase();
+ if (!EXTENSIONS.contains(ext)) {
+ reply(ex, 400, "application/json", error("mock: Invalid file format. Supported formats: " + EXTENSIONS,
+ "invalid_request_error"));
+ return;
+ }
+ String text = decode(mp.file);
+ String model = mp.fields.getOrDefault("model", "");
+ String format = mp.fields.getOrDefault("response_format", "json");
+ if (format.equals("text")) {
+ reply(ex, 200, "text/plain", text);
+ } else if (model.equals("gpt-transcribe")) {
+ reply(ex, 200, "application/json", JSON.writeValueAsString(
+ Map.of("text", text, "languages", List.of(Map.of("code", "en")))));
+ } else {
+ reply(ex, 200, "application/json", JSON.writeValueAsString(Map.of("text", text)));
+ }
+ }
+
+ /** Pitch decoder: tones back into script lines. See the class comment: this is the mock's "recogniser". */
+ static String decode(byte[] wav) {
+ Wav.Info info = Wav.parse(wav);
+ int win = info.sampleRate() / 20; // 50 ms
+ List out = new ArrayList<>();
+ int runStart = -1;
+ for (int f = 0; f + win <= info.frames() + win; f += win) {
+ boolean active = f + win <= info.frames() && rms(wav, info, f, win) > 500;
+ if (active && runStart < 0) runStart = f;
+ if (!active && runStart >= 0) {
+ out.add(sentence(wav, info, runStart, f));
+ runStart = -1;
+ }
+ }
+ return String.join(" ", out);
+ }
+
+ private static String sentence(byte[] wav, Wav.Info info, int from, int to) {
+ int crossings = 0, last = 0, first = -1, lastAt = -1; // hysteresis: only count swings between +1000 and -1000
+ for (int i = from; i < to; i++) {
+ short v = Wav.sample(wav, info, i);
+ int sign = v > 1000 ? 1 : v < -1000 ? -1 : 0;
+ if (sign != 0) {
+ if (last != 0 && sign != last) { crossings++; if (first < 0) first = i; lastAt = i; }
+ last = sign;
+ }
+ }
+ double seconds = (double) (to - from) / info.sampleRate();
+ // frequency from the span between the first and last crossing, so window edges do not matter
+ double hz = crossings < 3 ? 0 : (crossings - 1) / 2.0 / ((double) (lastAt - first) / info.sampleRate());
+ int idx = (int) Math.round((hz - 300) / 20);
+ if (idx < 0 || idx >= MeetingFixture.SCRIPT.size()) return "[inaudible]";
+ if (seconds < 0.6 * MeetingFixture.duration(idx)) return "[inaudible]";
+ return MeetingFixture.SCRIPT.get(idx);
+ }
+
+ private static double rms(byte[] wav, Wav.Info info, int from, int n) {
+ double sum = 0;
+ for (int i = 0; i < n; i++) { double s = Wav.sample(wav, info, from + i); sum += s * s; }
+ return Math.sqrt(sum / n);
+ }
+
+ // ---------------------------------------------------------------- speech
+
+ private void speech(HttpExchange ex) throws IOException {
+ byte[] body = ex.getRequestBody().readAllBytes();
+ String json = new String(body, StandardCharsets.UTF_8);
+ seen.add(new Seen("/v1/audio/speech", ex.getRequestHeaders().getFirst("Content-Type"), body.length,
+ Map.of(), null, null, 0, json));
+ JsonNode req = JSON.readTree(json);
+ String input = req.path("input").asText("");
+ if (input.length() > 4096) {
+ reply(ex, 400, "application/json", error("mock: the maximum length of input is 4096 characters, got "
+ + input.length(), "invalid_request_error"));
+ return;
+ }
+ double seconds = Math.max(0.5, input.length() / 15.0); // ~15 characters per second of speech
+ int rate = 8000, frames = (int) (seconds * rate);
+ byte[] pcm = new byte[frames * 2];
+ for (int f = 0; f < frames; f++) {
+ short v = (short) (3000 * Math.sin(2 * Math.PI * 440 * f / rate));
+ pcm[2 * f] = (byte) v;
+ pcm[2 * f + 1] = (byte) (v >> 8);
+ }
+ byte[] wav = Wav.wrap(pcm, 0, pcm.length, rate, 1, 16);
+ String fmt = req.path("response_format").asText("mp3");
+ reply(ex, 200, fmt.equals("wav") ? "audio/wav" : "audio/mpeg", wav);
+ }
+
+ // ---------------------------------------------------------------- plumbing
+
+ private static String error(String message, String type) {
+ return JSON.writeValueAsString(Map.of("error", Map.of("message", message, "type", type)));
+ }
+
+ private static void reply(HttpExchange ex, int status, String type, String body) throws IOException {
+ reply(ex, status, type, body.getBytes(StandardCharsets.UTF_8));
+ }
+
+ private static void reply(HttpExchange ex, int status, String type, byte[] body) throws IOException {
+ ex.getResponseHeaders().add("Content-Type", type);
+ ex.sendResponseHeaders(status, body.length);
+ ex.getResponseBody().write(body);
+ ex.close();
+ }
+
+ /** Just enough multipart/form-data. */
+ private static final class Multipart {
+ final Map fields = new LinkedHashMap<>();
+ String filename, fileType;
+ byte[] file;
+
+ static Multipart parse(byte[] body, String contentType) {
+ Multipart m = new Multipart();
+ if (contentType == null || !contentType.contains("boundary=")) return m;
+ String boundary = "--" + contentType.substring(contentType.indexOf("boundary=") + 9).replace("\"", "");
+ byte[] delim = boundary.getBytes(StandardCharsets.ISO_8859_1);
+ int pos = indexOf(body, delim, 0);
+ while (pos >= 0) {
+ int start = pos + delim.length;
+ if (start + 2 > body.length || (body[start] == '-' && body[start + 1] == '-')) break;
+ start += 2; // CRLF after the boundary
+ int next = indexOf(body, delim, start);
+ if (next < 0) break;
+ int headEnd = indexOf(body, "\r\n\r\n".getBytes(StandardCharsets.ISO_8859_1), start);
+ String head = new String(body, start, headEnd - start, StandardCharsets.ISO_8859_1);
+ int dataStart = headEnd + 4, dataEnd = next - 2; // CRLF before the next boundary
+ String name = attr(head, "name");
+ if (head.contains("filename=")) {
+ m.filename = attr(head, "filename");
+ m.fileType = head.lines().filter(l -> l.toLowerCase().startsWith("content-type:"))
+ .map(l -> l.substring(13).trim()).findFirst().orElse(null);
+ ByteArrayOutputStream bo = new ByteArrayOutputStream();
+ bo.write(body, dataStart, dataEnd - dataStart);
+ m.file = bo.toByteArray();
+ } else {
+ m.fields.put(name, new String(body, dataStart, dataEnd - dataStart, StandardCharsets.UTF_8));
+ }
+ pos = next;
+ }
+ return m;
+ }
+
+ private static String attr(String head, String key) {
+ int i = head.indexOf(key + "=\"");
+ if (i < 0) return null;
+ int s = i + key.length() + 2;
+ return head.substring(s, head.indexOf('"', s));
+ }
+
+ private static int indexOf(byte[] hay, byte[] needle, int from) {
+ outer:
+ for (int i = from; i <= hay.length - needle.length; i++) {
+ for (int j = 0; j < needle.length; j++) if (hay[i + j] != needle[j]) continue outer;
+ return i;
+ }
+ return -1;
+ }
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/support/MeetingFixture.java b/audio/src/test/java/com/ankurm/audio/support/MeetingFixture.java
new file mode 100644
index 0000000..f74a745
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/support/MeetingFixture.java
@@ -0,0 +1,108 @@
+package com.ankurm.audio.support;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.List;
+
+import com.ankurm.audio.Wav;
+
+/**
+ * A SYNTHETIC "meeting": 30 scripted sentences, each rendered as a pure tone whose pitch encodes
+ * the sentence number (300 Hz + 20 Hz x n), separated by ~25 seconds of low noise. It is not
+ * speech. The mock server decodes the pitch back into the script line, which lets the real Spring
+ * AI client and the real chunking code run end to end with no key and no model, and lets the
+ * tests check that no sentence was lost or cut in half.
+ */
+public final class MeetingFixture {
+
+ public static final int SAMPLE_RATE = 16_000;
+ public static final double FIRST_START = 11.0;
+ public static final double STEP = 32.0;
+ public static final double TAIL = 5.0;
+
+ public static final List SCRIPT = List.of(
+ "Okay, let's get started with the Falcon weekly sync.",
+ "First item is the release date for version two point four.",
+ "Rahul says the login timeout bug is the only blocker left.",
+ "Rahul will fix the login timeout bug before the release on the fourteenth of November.",
+ "Can we confirm QA has a full day on the thirteenth.",
+ "Meera confirms QA has the whole day on the thirteenth.",
+ "Decision: we ship version two point four on the fourteenth of November.",
+ "Next is the budget for the cloud account.",
+ "Priya noted that spend is twelve percent over plan this quarter.",
+ "Priya will send the revised budget to finance by Friday.",
+ "Does anyone object to moving the data pipeline to the new cluster.",
+ "No objections, the pipeline moves to the new cluster next sprint.",
+ "Decision: the data pipeline migrates to the new cluster next sprint.",
+ "Let's talk about the offsite in December.",
+ "Meera will book the venue for the offsite and share options by Wednesday.",
+ "Arjun asked whether we still need the staging database.",
+ "We keep staging until the migration is finished.",
+ "Arjun will write up the staging database retirement plan after the migration.",
+ "Any updates on the security review.",
+ "The review found two medium issues, both in the export endpoint.",
+ "Sana will open tickets for both export endpoint issues today.",
+ "Decision: the export endpoint fixes are not release blockers.",
+ "Quick note that the on call rotation changes next month.",
+ "Everyone should check the new rotation sheet before the end of this week.",
+ "Any other business.",
+ "Rahul wants a second reviewer on the login fix.",
+ "Sana will review the login fix once Rahul opens the pull request.",
+ "Great, that is everything on the list.",
+ "Thanks everyone, the notes will go out this afternoon.",
+ "Meeting closed.");
+
+ private MeetingFixture() {}
+
+ /** Seconds of tone for sentence {@code i}: proportional to its word count. */
+ private static final double[] DURATIONS = SCRIPT.stream()
+ .mapToDouble(line -> 1.5 + 0.35 * line.split("\\s+").length).toArray();
+
+ public static double duration(int i) {
+ return DURATIONS[i];
+ }
+
+ public static double start(int i) {
+ return FIRST_START + STEP * i;
+ }
+
+ public static double pitch(int i) {
+ return 300 + 20 * i;
+ }
+
+ public static double totalSeconds() {
+ return start(SCRIPT.size() - 1) + duration(SCRIPT.size() - 1) + TAIL;
+ }
+
+ /** The whole recording as a 16 kHz mono 16-bit WAV (about 30 MB). */
+ public static byte[] wav() {
+ return CACHE;
+ }
+
+ private static final byte[] CACHE = build();
+
+ private static byte[] build() {
+ int frames = (int) (totalSeconds() * SAMPLE_RATE);
+ ByteBuffer pcm = ByteBuffer.allocate(frames * 2).order(ByteOrder.LITTLE_ENDIAN);
+ long seed = 42;
+ for (int f = 0; f < frames; f++) {
+ seed = seed * 6364136223846793005L + 1442695040888963407L;
+ double v = ((seed >>> 33) % 81) - 40; // +-40 of room noise
+ double t = (double) f / SAMPLE_RATE;
+ int i = (int) Math.floor((t - FIRST_START) / STEP);
+ if (i >= 0 && i < SCRIPT.size() && t < start(i) + duration(i)) {
+ v += 8000 * Math.sin(2 * Math.PI * pitch(i) * (t - start(i)));
+ }
+ pcm.putShort((short) Math.round(v));
+ }
+ return Wav.wrap(pcm.array(), 0, pcm.capacity(), SAMPLE_RATE, 1, 16);
+ }
+
+ /** Which sentence does this exact slice of time fall inside, or -1 for silence. */
+ public static int sentenceAt(double seconds) {
+ for (int i = 0; i < SCRIPT.size(); i++) {
+ if (seconds >= start(i) && seconds < start(i) + duration(i)) return i;
+ }
+ return -1;
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/support/Models.java b/audio/src/test/java/com/ankurm/audio/support/Models.java
new file mode 100644
index 0000000..ce10bf6
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/support/Models.java
@@ -0,0 +1,28 @@
+package com.ankurm.audio.support;
+
+import org.springframework.ai.openai.OpenAiAudioSpeechModel;
+import org.springframework.ai.openai.OpenAiAudioSpeechOptions;
+import org.springframework.ai.openai.OpenAiAudioTranscriptionModel;
+import org.springframework.ai.openai.OpenAiAudioTranscriptionOptions;
+
+/** The two real Spring AI OpenAI audio models, pointed at the local mock. */
+public final class Models {
+
+ private Models() {}
+
+ public static OpenAiAudioTranscriptionModel transcription(String baseUrl, String model) {
+ return transcription(baseUrl, model, null);
+ }
+
+ public static OpenAiAudioTranscriptionModel transcription(String baseUrl, String model, Integer maxRetries) {
+ OpenAiAudioTranscriptionOptions.Builder o = OpenAiAudioTranscriptionOptions.builder()
+ .baseUrl(baseUrl).apiKey("test-key-not-real").model(model);
+ if (maxRetries != null) o.maxRetries(maxRetries);
+ return OpenAiAudioTranscriptionModel.builder().options(o.build()).build();
+ }
+
+ public static OpenAiAudioSpeechModel speech(String baseUrl, String model) {
+ return OpenAiAudioSpeechModel.builder().options(OpenAiAudioSpeechOptions.builder()
+ .baseUrl(baseUrl).apiKey("test-key-not-real").model(model).build()).build();
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/support/ScriptedChatModel.java b/audio/src/test/java/com/ankurm/audio/support/ScriptedChatModel.java
new file mode 100644
index 0000000..5bbaf5a
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/support/ScriptedChatModel.java
@@ -0,0 +1,36 @@
+package com.ankurm.audio.support;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.ai.chat.messages.AssistantMessage;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.chat.model.ChatResponse;
+import org.springframework.ai.chat.model.Generation;
+import org.springframework.ai.chat.prompt.Prompt;
+
+/**
+ * A ChatModel that replays canned replies and remembers every prompt it received. STUB: it is not
+ * a language model and understands nothing in the prompt.
+ */
+public final class ScriptedChatModel implements ChatModel {
+
+ private final List replies;
+ private final List seen = new ArrayList<>();
+ private int next;
+
+ public ScriptedChatModel(String... replies) {
+ this.replies = List.of(replies);
+ }
+
+ @Override
+ public ChatResponse call(Prompt prompt) {
+ seen.add(prompt);
+ String reply = replies.get(Math.min(next++, replies.size() - 1));
+ return new ChatResponse(List.of(new Generation(new AssistantMessage(reply))));
+ }
+
+ public List prompts() {
+ return seen;
+ }
+}
diff --git a/audio/src/test/java/com/ankurm/audio/support/Transcript.java b/audio/src/test/java/com/ankurm/audio/support/Transcript.java
new file mode 100644
index 0000000..40f7e21
--- /dev/null
+++ b/audio/src/test/java/com/ankurm/audio/support/Transcript.java
@@ -0,0 +1,46 @@
+package com.ankurm.audio.support;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Writes a numbered transcript under {@code output/} (module root, not {@code docs/}) and echoes
+ * it to the console. Every console block quoted in the article comes out of one of these files.
+ */
+public final class Transcript implements AutoCloseable {
+
+ private final Path path;
+ private final StringWriter buffer = new StringWriter();
+ private final PrintWriter out = new PrintWriter(buffer);
+
+ public Transcript(String fileName, String title) {
+ this.path = Path.of("output", fileName);
+ out.println("# " + title);
+ out.println();
+ }
+
+ public Transcript line(String format, Object... args) {
+ out.println(args.length == 0 ? format : String.format(format, args));
+ return this;
+ }
+
+ public Transcript blank() {
+ out.println();
+ return this;
+ }
+
+ @Override
+ public void close() {
+ out.flush();
+ try {
+ Files.createDirectories(path.getParent());
+ Files.writeString(path, buffer.toString());
+ } catch (IOException e) {
+ throw new IllegalStateException("could not write " + path, e);
+ }
+ System.out.print(buffer);
+ }
+}