Skip to content

feat: support live transcription replay #345

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
jpr5 wants to merge 2 commits into
base: main
Choose a base branch
from
Open

feat: support live transcription replay #345

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
32fc5be
feat: support OpenAI transcription replay
jpr5 Jul 30, 2026
23aca19
test: cover transcription replay contracts
jpr5 Jul 30, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
170 changes: 170 additions & 0 deletions src/__tests__/multimedia-record.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@ import * as fs from "node:fs";
import * as os from "node:os";
import * as path from "node:path";
import { proxyAndRecord } from "../recorder.js";
import { createServer } from "../server.js";
import type { Fixture, RecordConfig, ChatCompletionRequest } from "../types.js";
import { Logger } from "../logger.js";

Expand Down Expand Up @@ -77,6 +78,21 @@ function makeTmpDir(): string {
return fs.mkdtempSync(path.join(os.tmpdir(), "aimock-mm-record-"));
}

async function requestStreamingTranscription(url: string): Promise<Response> {
const formData = new FormData();
formData.append("file", new Blob(["audio"], { type: "audio/wav" }), "audio.wav");
formData.append("model", "gpt-transcribe");
formData.append("stream", "true");
return fetch(`${url}/v1/audio/transcriptions`, { method: "POST", body: formData });
}

async function requestJsonTranscription(url: string): Promise<Response> {
const formData = new FormData();
formData.append("file", new Blob(["audio"], { type: "audio/wav" }), "audio.wav");
formData.append("model", "gpt-transcribe");
return fetch(`${url}/v1/audio/transcriptions`, { method: "POST", body: formData });
}

// ---------------------------------------------------------------------------
// Tests: buildFixtureResponse detection via proxyAndRecord
// ---------------------------------------------------------------------------
Expand Down Expand Up @@ -207,6 +223,160 @@ describe("multimedia record: image response detection", () => {
});

describe("multimedia record: transcription response detection", () => {
it("records upstream gpt-transcribe SSE and replays it through the local handler", async () => {
const fixturePath = makeTmpDir();
const upstreamBody =
'data: {"type":"transcript.text.delta","delta":"Recorded "}\n\n' +
'data: {"type":"transcript.text.delta","delta":"stream"}\n\n' +
'data: {"type":"transcript.text.done","text":"Recorded stream","languages":[{"code":"en"}],"usage":{"type":"tokens","input_tokens":4,"output_tokens":5,"total_tokens":9}}\n\n';
const { server: upstream, url } = await createUpstream((_req, res) => {
res.writeHead(200, { "Content-Type": "text/event-stream" });
res.end(upstreamBody);
});
const fixtures: Fixture[] = [];
const recorder = await createServer(fixtures, {
port: 0,
record: { providers: { openai: url }, fixturePath },
});

try {
const recorded = await requestStreamingTranscription(recorder.url);
expect(recorded.status).toBe(200);
expect(await recorded.text()).toBe(upstreamBody);
expect(fixtures).toHaveLength(1);
expect(fixtures[0].response).toEqual({
transcription: {
text: "Recorded stream",
languages: [{ code: "en" }],
usage: { type: "tokens", input_tokens: 4, output_tokens: 5, total_tokens: 9 },
},
});

const savedFixture = JSON.parse(
fs.readFileSync(
path.join(
fixturePath,
fs.readdirSync(fixturePath).find((file) => file.endsWith(".json"))!,
),
"utf8",
),
);
expect(savedFixture.fixtures[0].response).toEqual({
transcription: {
text: "Recorded stream",
languages: [{ code: "en" }],
usage: { type: "tokens", input_tokens: 4, output_tokens: 5, total_tokens: 9 },
},
});

const replay = await requestStreamingTranscription(recorder.url);
expect(replay.status).toBe(200);
expect(await replay.text()).toBe(
'data: {"type":"transcript.text.delta","delta":"Recorded stream"}\n\n' +
'data: {"type":"transcript.text.done","text":"Recorded stream","languages":[{"code":"en"}],"usage":{"type":"tokens","input_tokens":4,"output_tokens":5,"total_tokens":9}}\n\n',
);
} finally {
await closeServer(recorder.server);
await closeServer(upstream);
fs.rmSync(fixturePath, { recursive: true, force: true });
}
});

it("records and replays the modern gpt-transcribe text languages and usage response", async () => {
const fixturePath = makeTmpDir();
const { server, url } = await createUpstream((_req, res) => {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(
JSON.stringify({
text: "Modern transcript",
languages: [{ code: "en" }, { code: "es" }],
usage: { type: "tokens", input_tokens: 4, output_tokens: 5, total_tokens: 9 },
}),
);
});

try {
const fixtures: Fixture[] = [];
const record: RecordConfig = { providers: { openai: url }, fixturePath };
const logger = new Logger("silent");
const request: ChatCompletionRequest = {
model: "gpt-transcribe",
messages: [],
_endpointType: "transcription",
};

const { req, res } = createMockReqRes("/v1/audio/transcriptions");
await proxyAndRecord(req, res, request, "openai", "/v1/audio/transcriptions", fixtures, {
record,
logger,
});

const response = fixtures[0].response as {
transcription?: {
text: string;
languages?: Array<{ code: string }>;
usage?: Record<string, unknown>;
};
};
expect(response.transcription).toEqual({
text: "Modern transcript",
languages: [{ code: "en" }, { code: "es" }],
usage: { type: "tokens", input_tokens: 4, output_tokens: 5, total_tokens: 9 },
});
} finally {
await closeServer(server);
fs.rmSync(fixturePath, { recursive: true, force: true });
}
});

it("records and locally replays JSON transcription languages and usage", async () => {
const fixturePath = makeTmpDir();
const { server: upstream, url } = await createUpstream((_req, res) => {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(
JSON.stringify({
text: "Recorded JSON transcript",
languages: [{ code: "en" }, { code: "fr" }],
usage: { type: "tokens", input_tokens: 3, output_tokens: 4, total_tokens: 7 },
}),
);
});
const fixtures: Fixture[] = [];
const recorder = await createServer(fixtures, {
port: 0,
record: { providers: { openai: url }, fixturePath },
});

try {
const recorded = await requestJsonTranscription(recorder.url);
expect(recorded.status).toBe(200);
expect(await recorded.json()).toEqual({
text: "Recorded JSON transcript",
languages: [{ code: "en" }, { code: "fr" }],
usage: { type: "tokens", input_tokens: 3, output_tokens: 4, total_tokens: 7 },
});
expect(fixtures[0].response).toEqual({
transcription: {
text: "Recorded JSON transcript",
languages: [{ code: "en" }, { code: "fr" }],
usage: { type: "tokens", input_tokens: 3, output_tokens: 4, total_tokens: 7 },
},
});

const replay = await requestJsonTranscription(recorder.url);
expect(replay.status).toBe(200);
expect(await replay.json()).toEqual({
text: "Recorded JSON transcript",
languages: [{ code: "en" }, { code: "fr" }],
usage: { type: "tokens", input_tokens: 3, output_tokens: 4, total_tokens: 7 },
});
} finally {
await closeServer(recorder.server);
await closeServer(upstream);
fs.rmSync(fixturePath, { recursive: true, force: true });
}
});

it("detects OpenAI transcription response", async () => {
const fixturePath = makeTmpDir();
const { server, url } = await createUpstream((_req, res) => {
Expand Down
Loading
Loading