@cartanova/qgrid-ai-sdk 2.15.3 → 2.15.4

package/README.ko.md

@@ -347,8 +347,8 @@ qgrid는 `grok/*` 모델을 qgrid 대시보드에 등록한 xAI 구독 토큰(
 | `qgrid(id)` | `grok/grok-4.7`(카탈로그 기본 모델), `grok/grok-4.7-build-fast`, `grok/grok-4.6`, `grok/grok-4.5`, 그 밖의 `grok/<id>` | `generateText`, `streamText` |
 | `qgrid.image(id)` | `grok/grok-imagine-image`, `grok/grok-imagine-image-2.0` | `generateImage` |
 | `qgrid.video(id)` | `grok/grok-imagine-video`, `grok/grok-imagine-video-1.5`, `grok/grok-imagine-video-1.5-lite` | `experimental_generateVideo` |
-| `qgrid.transcription(id)` | `grok/grok-voice-transcribe-2.0` | `transcribe` |
-| `qgrid.speech(id)` | `grok/grok-tts`(ID는 request log 라벨로만 쓰임) | `generateSpeech` |
+| `qgrid.transcription(id)` | `grok/grok-voice-transcribe-2.0`; OpenAI 구독: `openai/gpt-4o-mini-transcribe`, `openai/gpt-4o-transcribe`, `openai/gpt-transcribe`, `openai/gpt-live-transcribe`, `openai/gpt-realtime-whisper`, `openai/whisper-1` | `transcribe` |
+| `qgrid.speech(id)` | `grok/grok-tts`(ID는 request log 라벨로만 쓰임); OpenAI 구독: `openai/gpt-realtime-2.1-mini`, `openai/gpt-realtime-2.1`, `openai/gpt-realtime-1.5` | `generateSpeech` |
 
 qgrid는 카탈로그에 없는 language model ID를 거부하지 않고 그대로 전달합니다(OpenAI와 같음). 판단은
 subscription backend가 하며 다른 모델로 응답할 수 있으므로, 실제로 실행된 모델은 request log의 응답 모델(또는
@@ -488,6 +488,35 @@ speech.audio.uint8Array;
 - `transcribe`는 bytes로 오디오 형식을 감지하고 실패하면 `audio/wav`를 씁니다. 서버는 `audio/*`가 아닌 값을 거부합니다. transcript에는 segment가 없습니다(`segments: []`).
 - 음성 합성 텍스트는 최대 15,000자입니다. `voice`, `language`, `outputFormat`을 지정하지 않으면 서버 기본값 `ara`, `en`, `mp3`가 쓰이며, live 검증된 조합은 이것뿐입니다. 다른 voice, language(`@ai-sdk/xai`의 `auto` 포함), codec은 그대로 전달되지만 미검증입니다. 서버가 돌려준 오디오 MIME 타입은 `providerMetadata.qgrid.mediaType`에 있고, AI SDK의 `speech.audio.mediaType`은 bytes에서 추정한 값입니다.
 
+### OpenAI 음성 인식과 합성 (ChatGPT 구독)
+
+`openai/` 음성 ID는 qgrid가 Codex에 쓰는 ChatGPT 구독 토큰으로 OpenAI realtime 세션을 사용합니다. 음성 인식은 Codex의 `/realtime/calls` 흐름을, 음성 합성은 텍스트를 그대로 읽는 realtime 대화 모델을 씁니다(구독에는 `gpt-4o-mini-tts`, `tts-1`이 없습니다). 옵션은 `providerOptions.openai` 아래 `@ai-sdk/openai` 이름을 따르고, `providerOptions.qgrid.tokenName`은 `openai/` 접두사가 필요합니다.
+
+```typescript
+const transcript = await transcribe({
+  model: qgrid.transcription("openai/gpt-4o-mini-transcribe"),
+  audio: await readFile("meeting.wav"), // PCM16 WAV 또는 raw PCM만
+  providerOptions: { openai: { language: "en", prompt: "qgrid, Codex" } },
+});
+
+const speech = await generateSpeech({
+  model: qgrid.speech("openai/gpt-realtime-2.1-mini"),
+  text: "Your build is ready.",
+  voice: "marin",
+  outputFormat: "wav",
+  providerOptions: { openai: { instructions: "Calm and brisk." } },
+});
+```
+
+| 모델 | 그대로 전달(`@ai-sdk/openai` 이름) | 변환 | 미지원(경고) |
+| --- | --- | --- | --- |
+| Transcription | `openai.language`, `openai.prompt`(`gpt-realtime-whisper`는 HTTP 400으로 거부, `whisper-1`은 받지만 업스트림이 무시) | 입력은 PCM16 WAV(`audio/wav`) 또는 raw PCM(`audio/pcm;rate=…;channels=…`)만 가능하며 mp3/webm/ogg는 디코더가 추가되기 전까지 서버가 HTTP 400으로 거부합니다. `durationInSeconds`는 보낸 오디오에서 계산하고 `language`는 요청값을 그대로 돌려줍니다(realtime 세션은 둘 다 보고하지 않음). `segments`는 비어 있습니다 | `openai.temperature`, `openai.include`, `openai.timestampGranularities`, `openai.responseFormat`, `openai.chunkingStrategy`, `openai.streaming` |
+| Speech | `voice`(기본 `marin`; Codex v2 목록 `alloy ash ballad coral echo sage shimmer verse marin cedar`, 그 외는 HTTP 400), `instructions` / `openai.instructions`(원문 그대로 읽기 지시문 뒤에 붙는 스타일 안내) | `outputFormat`은 `wav`(기본, PCM16 24 kHz) 또는 `pcm`; 그 외 값은 `@ai-sdk/openai`가 `mp3`로 되돌리듯 경고와 함께 `wav`로 바뀝니다 | `language`, `speed`, `openai.speed` |
+
+- 음성 인식은 먼저 Codex realtime call에서 25초 예산으로 실행됩니다(call은 생성 약 30초 뒤 정리됨). 그 안에 전사가 오지 않으면 서버가 직접 realtime 전사 소켓으로 1회 재시도합니다(최대 60초). 7 MiB 인라인 제한(24 kHz PCM 약 2.5분)은 보통 첫 경로에서 몇 초 안에 끝납니다.
+- 음성 합성은 TTS 모델이 아니라 텍스트를 읽는 대화 모델입니다. qgrid는 `<script>` 태그 안의 텍스트만 읽고 답하지 말라고 지시합니다. 원문 그대로 읽는지는 짧은 영어 문장과 질문형 영어 캐릭터 대사에서 검증했습니다. 모델이 실제로 말한 transcript를 요청 로그에 함께 남겨 비교할 수 있지만, 한영 혼합 텍스트에서는 transcript가 일치해도 영어 음성을 알아듣기 어려운 경우가 있었습니다.
+- 모델별 동작은 서버 저장소의 `docs/diagnosis/2026-10-17-openai-realtime-audio-probe.md`에 기록되어 있습니다. 2026-10-17 기준 알려진 한계: `gpt-live-transcribe`, `gpt-realtime-whisper`는 60초 클립의 절반 정도만 반환하므로 짧은 발화에 쓰세요. `gpt-realtime-whisper`는 `openai.prompt`를 거부합니다(서버가 업스트림 호출 전에 HTTP 400). `whisper-1`은 `openai.prompt`를 받지만 무시합니다. 음성 합성은 `gpt-realtime-2.1-mini`가 모든 테스트 문장을 그대로 읽었고(13/13), `gpt-realtime-2.1`은 1회 의역(12/13), `gpt-realtime-1.5`는 텍스트를 읽지 않고 답변하는 경우가 잦았습니다(6/13). 2026-11-06에는 현재 프롬프트로 `gpt-realtime-2.1`과 `gpt-realtime-2.1-mini` 모두 질문형 캐릭터 대사 12/12를 그대로 읽었습니다(이전 프롬프트에서는 `gpt-realtime-2.1`이 7/12를 답변). `gpt-realtime-1.5`는 다시 측정하지 않았습니다. 정확성이 중요하면 로그의 transcript를 입력과 비교하세요.
+
 ## Telemetry Logger
 
 서버와 AI SDK 2.10.0부터 qgrid provider의 `generateText` 결과에서는 `result.finalStep.providerMetadata?.qgrid?.requestLogId`로 요청 로그 ID를 확인할 수 있습니다. `streamText`는 스트림 소비 후 `(await result.finalStep).providerMetadata?.qgrid?.requestLogId`로 확인합니다. 직접 API를 호출하면 `query` 응답과 스트림 `done` 이벤트의 최상위 `requestLogId`에 같은 값이 담깁니다. `logger: false` 또는 구버전 서버에서는 이 필드가 없으며, 툴 호출 후속 단계는 같은 요청 로그 ID를 공유합니다. 이 ID는 후속 요청 연결 상태가 아니며, 아래 telemetry logger를 쓰는 외부 provider에는 이 metadata가 추가되지 않습니다.

package/README.md

@@ -357,8 +357,8 @@ Grok model accepts the same factory config as the other models: `serverUrl` (def
 | `qgrid(id)` | `grok/grok-4.7` (default catalog model), `grok/grok-4.7-build-fast`, `grok/grok-4.6`, `grok/grok-4.5`, any other `grok/<id>` | `generateText`, `streamText` |
 | `qgrid.image(id)` | `grok/grok-imagine-image`, `grok/grok-imagine-image-2.0` | `generateImage` |
 | `qgrid.video(id)` | `grok/grok-imagine-video`, `grok/grok-imagine-video-1.5`, `grok/grok-imagine-video-1.5-lite` | `experimental_generateVideo` |
-| `qgrid.transcription(id)` | `grok/grok-voice-transcribe-2.0` | `transcribe` |
-| `qgrid.speech(id)` | `grok/grok-tts` (the id only labels the request log) | `generateSpeech` |
+| `qgrid.transcription(id)` | `grok/grok-voice-transcribe-2.0`; OpenAI subscription: `openai/gpt-4o-mini-transcribe`, `openai/gpt-4o-transcribe`, `openai/gpt-transcribe`, `openai/gpt-live-transcribe`, `openai/gpt-realtime-whisper`, `openai/whisper-1` | `transcribe` |
+| `qgrid.speech(id)` | `grok/grok-tts` (the id only labels the request log); OpenAI subscription: `openai/gpt-realtime-2.1-mini`, `openai/gpt-realtime-2.1`, `openai/gpt-realtime-1.5` | `generateSpeech` |
 
 qgrid forwards a language-model id that is not in its catalog unchanged instead of rejecting it,
 as it does for OpenAI; the subscription backend decides. It may serve a different model, so check
@@ -500,6 +500,35 @@ speech.audio.uint8Array;
 - `transcribe` detects the audio type from its bytes and falls back to `audio/wav`; the server rejects anything that is not `audio/*`. Transcripts carry no segments (`segments: []`).
 - Speech text is limited to 15,000 characters. Unset `voice`, `language` and `outputFormat` use the server defaults `ara`, `en` and `mp3`, the only combination verified live. Other voices, languages (including `@ai-sdk/xai`'s `auto`) and codecs are passed through but unverified. The server's audio MIME type is in `providerMetadata.qgrid.mediaType`; AI SDK's `speech.audio.mediaType` is sniffed from the bytes.
 
+### OpenAI transcription and speech (ChatGPT subscription)
+
+`openai/` voice ids run on OpenAI realtime sessions with the same ChatGPT subscription tokens qgrid uses for Codex: transcription through the Codex `/realtime/calls` flow, speech through a realtime conversational model that repeats the text verbatim (there is no `gpt-4o-mini-tts` or `tts-1` on subscription). Options follow `@ai-sdk/openai` under `providerOptions.openai`; `providerOptions.qgrid.tokenName` must carry the `openai/` prefix.
+
+```typescript
+const transcript = await transcribe({
+  model: qgrid.transcription("openai/gpt-4o-mini-transcribe"),
+  audio: await readFile("meeting.wav"), // PCM16 WAV or raw PCM only
+  providerOptions: { openai: { language: "en", prompt: "qgrid, Codex" } },
+});
+
+const speech = await generateSpeech({
+  model: qgrid.speech("openai/gpt-realtime-2.1-mini"),
+  text: "Your build is ready.",
+  voice: "marin",
+  outputFormat: "wav",
+  providerOptions: { openai: { instructions: "Calm and brisk." } },
+});
+```
+
+| Model | Faithful (`@ai-sdk/openai` names) | Transformed | Unsupported (warning) |
+| --- | --- | --- | --- |
+| Transcription | `openai.language`, `openai.prompt` (not on `gpt-realtime-whisper`, which rejects it with HTTP 400; accepted but ignored upstream on `whisper-1`) | input must be PCM16 WAV (`audio/wav`) or raw PCM (`audio/pcm;rate=…;channels=…`); mp3/webm/ogg are rejected by the server with HTTP 400 until a decoder lands. `durationInSeconds` is computed from the audio sent; `language` echoes the request (the realtime session reports neither); `segments` is empty | `openai.temperature`, `openai.include`, `openai.timestampGranularities`, `openai.responseFormat`, `openai.chunkingStrategy`, `openai.streaming` |
+| Speech | `voice` (default `marin`; Codex v2 list `alloy ash ballad coral echo sage shimmer verse marin cedar`, others fail with HTTP 400), `instructions` / `openai.instructions` (style guidance appended to the verbatim-repeat prompt) | `outputFormat` `wav` (default, PCM16 24 kHz) or `pcm`; anything else falls back to `wav` with a warning, as `@ai-sdk/openai` falls back to `mp3` | `language`, `speed`, `openai.speed` |
+
+- Each transcription first runs on the Codex realtime call with a 25 s budget (the call is torn down about 30 s after creation); if that window closes before the transcript arrives, the server retries once on the direct realtime transcription socket (up to 60 s). The 7 MiB inline limit (~2.5 min of 24 kHz PCM) normally completes in a few seconds on the first path.
+- Speech is a conversational model reading text, not a TTS model. qgrid's prompt tells it to read only the text inside `<script>` tags and never answer it. Verbatim fidelity was verified on short English sentences and on question-form English character lines. The model's own transcript of what it said is logged with the request for comparison, but for mixed Korean/English text a matching transcript did not guarantee intelligible English audio.
+- Per-model behavior is recorded in the server repository's `docs/diagnosis/2026-10-17-openai-realtime-audio-probe.md`. Known limits on 2026-10-17: `gpt-live-transcribe` and `gpt-realtime-whisper` returned roughly half of a 60 s clip (use them for short utterances); `gpt-realtime-whisper` rejects `openai.prompt` (the server answers HTTP 400 before any upstream call); `whisper-1` accepts but ignores `openai.prompt`. For speech, `gpt-realtime-2.1-mini` repeated every test text verbatim (13/13), `gpt-realtime-2.1` paraphrased once (12/13), and `gpt-realtime-1.5` often answered the text instead of repeating it (6/13). On 2026-11-06, with the current prompt, `gpt-realtime-2.1` and `gpt-realtime-2.1-mini` both read 12/12 question-form character lines verbatim (the earlier prompt let `gpt-realtime-2.1` answer 7/12); `gpt-realtime-1.5` was not re-run. Compare the logged transcript with your input when fidelity matters.
+
 ## Telemetry Logger
 
 With qgrid server and SDK 2.10.0+, read the parent request-log ID from `result.finalStep.providerMetadata?.qgrid?.requestLogId` after `generateText`. For `streamText`, consume the stream first, then read `(await result.finalStep).providerMetadata?.qgrid?.requestLogId`. Raw API query responses and stream `done` events expose the same ID as top-level `requestLogId`. The field is omitted with `logger: false` or an older server. Tool-run steps share the parent ID; it is not continuation state. This metadata applies to the qgrid provider, not external providers using the telemetry logger below.

package/dist/index.d.ts

@@ -40,12 +40,28 @@ type QgridImageModel = "openai/gpt-image-2" | "grok/grok-imagine-image" | "grok/
 /** Grok video generation model ids (xAI subscription; not yet wired to a provider factory). */
 type QgridVideoModel = "grok/grok-imagine-video" | "grok/grok-imagine-video-1.5" | "grok/grok-imagine-video-1.5-lite";
 /** Grok speech-to-text model ids. */
-type QgridTranscriptionModel = "grok/grok-voice-transcribe-2.0";
+type QgridGrokTranscriptionModel = "grok/grok-voice-transcribe-2.0";
+/**
+ * OpenAI subscription speech-to-text ids, served through a realtime transcription session.
+ * Known limits (2026-10-17 live matrix): `gpt-live-transcribe` and `gpt-realtime-whisper`
+ * returned about half of a 60 s clip; `gpt-realtime-whisper` rejects `openai.prompt` (HTTP 400
+ * before any upstream call); `whisper-1` accepts `openai.prompt` without error but the upstream
+ * ignores it, so it cannot steer spelling.
+ */
+type QgridOpenAITranscriptionModel = "openai/gpt-4o-mini-transcribe" | "openai/gpt-4o-transcribe" | "openai/gpt-transcribe" | "openai/gpt-live-transcribe" | "openai/gpt-realtime-whisper" | "openai/whisper-1";
+type QgridTranscriptionModel = QgridGrokTranscriptionModel | QgridOpenAITranscriptionModel;
 /**
  * Grok text-to-speech model id. Placeholder: the live probe verified the `/tts` endpoint with the
  * subscription JWT, but no TTS model id was observed (`/speech-models` returned 404).
  */
-type QgridSpeechModel = "grok/grok-tts";
+type QgridGrokSpeechModel = "grok/grok-tts";
+/**
+ * OpenAI subscription text-to-speech ids: realtime conversational models repeating the text
+ * (`gpt-4o-mini-tts`/`tts-1` are unavailable on subscription). Verbatim fidelity on 2026-10-17:
+ * `gpt-realtime-2.1-mini` 13/13, `gpt-realtime-2.1` 12/13, `gpt-realtime-1.5` 6/13.
+ */
+type QgridOpenAISpeechModel = "openai/gpt-realtime-2.1-mini" | "openai/gpt-realtime-2.1" | "openai/gpt-realtime-1.5";
+type QgridSpeechModel = QgridGrokSpeechModel | QgridOpenAISpeechModel;
 type QgridImageProviderConfig = QgridCommonProviderConfig;
 /** `providerOptions.qgrid` for `generateImage({ model: qgrid.image(...) })`. */
 type QgridImageProviderOptions = {
@@ -219,6 +235,12 @@ type QgridLoggerConfig = {
 export declare const QGRID_MAX_REQUEST_BODY_BYTES: number;
 /** `config` for `qgrid.image/video/transcription/speech`; same fields as the language model. */
 type QgridMediaProviderConfig = QgridImageProviderConfig;
+declare const openaiQgridOptionsSchema: z.ZodObject<{
+  tokenName: z.ZodOptional<z.ZodString>;
+  logger: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `providerOptions.qgrid` accepted by OpenAI voice models. */
+type QgridOpenAIMediaProviderOptions = z.infer<typeof openaiQgridOptionsSchema>;
 /** Non-2xx response from a qgrid media endpoint. */
 export declare class QgridMediaHttpError extends Error {
   readonly status: number;
@@ -253,6 +275,10 @@ declare const xaiImageOptionsSchema: z.ZodObject<{
 type QgridXaiImageProviderOptions = z.infer<typeof xaiImageOptionsSchema>;
 //#endregion
 //#region src/speech-model.d.ts
+/** `providerOptions.openai` honored by `qgrid.speech("openai/...")`. */
+type QgridOpenAISpeechProviderOptions = {
+  instructions?: string;
+};
 /**
  * Grok text-to-speech through `POST /api/qgrid/speak`. `voice`, `language` and `outputFormat`
  * map to the server's `voice`, `language` and `format`; when omitted the server applies
@@ -265,6 +291,18 @@ declare function createQgridSpeech(modelId: QgridSpeechModel, config?: QgridMedi
 type QgridXaiTranscriptionProviderOptions = {
   language?: string;
 };
+/**
+ * `providerOptions.openai` honored by `qgrid.transcription("openai/...")`.
+ *
+ * `prompt` steers vocabulary on `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`, `gpt-transcribe`
+ * and `gpt-live-transcribe`. `openai/gpt-realtime-whisper` rejects it (the server answers HTTP
+ * 400 before any upstream call). `openai/whisper-1` accepts it but the upstream ignores it
+ * (verified 2026-10-17: "qgrid" still came back as "Thread"), so do not rely on it for spelling.
+ */
+type QgridOpenAITranscriptionProviderOptions = {
+  language?: string;
+  prompt?: string;
+};
 declare function createQgridTranscription(modelId: QgridTranscriptionModel, config?: QgridMediaProviderConfig): TranscriptionModelV3;
 //#endregion
 //#region src/video-model.d.ts
@@ -337,4 +375,4 @@ export declare namespace qgrid {
   var speech: typeof createQgridSpeech;
 }
 //#endregion
-export { type QgridAnthropicEffort, type QgridAnthropicModel, type QgridAnthropicProviderConfig, type QgridAnthropicProviderOptions, type QgridGrokEffort, type QgridGrokMediaProviderOptions, type QgridGrokModel, type QgridImageGenerationMetadata, type QgridImageModel, type QgridImageProviderConfig, type QgridImageProviderOptions, type QgridLoggerConfig, type QgridMediaProviderConfig, type QgridOpenAIEffort, type QgridOpenAIModel, type QgridOpenAIProviderConfig, type QgridOpenAIProviderOptions, type QgridProviderConfig, type QgridProviderOptions, type QgridSpeechModel, type QgridSupportedModel, type QgridTranscriptionModel, type QgridVideoModel, type QgridVideoPollOptions, type QgridVideoResult, type QgridXaiImageProviderOptions, type QgridXaiProviderOptions, type QgridXaiTranscriptionProviderOptions, type QgridXaiVideoProviderOptions, qgrid as default };
+export { type QgridAnthropicEffort, type QgridAnthropicModel, type QgridAnthropicProviderConfig, type QgridAnthropicProviderOptions, type QgridGrokEffort, type QgridGrokMediaProviderOptions, type QgridGrokModel, type QgridGrokSpeechModel, type QgridGrokTranscriptionModel, type QgridImageGenerationMetadata, type QgridImageModel, type QgridImageProviderConfig, type QgridImageProviderOptions, type QgridLoggerConfig, type QgridMediaProviderConfig, type QgridOpenAIEffort, type QgridOpenAIMediaProviderOptions, type QgridOpenAIModel, type QgridOpenAIProviderConfig, type QgridOpenAIProviderOptions, type QgridOpenAISpeechModel, type QgridOpenAISpeechProviderOptions, type QgridOpenAITranscriptionModel, type QgridOpenAITranscriptionProviderOptions, type QgridProviderConfig, type QgridProviderOptions, type QgridSpeechModel, type QgridSupportedModel, type QgridTranscriptionModel, type QgridVideoModel, type QgridVideoPollOptions, type QgridVideoResult, type QgridXaiImageProviderOptions, type QgridXaiProviderOptions, type QgridXaiTranscriptionProviderOptions, type QgridXaiVideoProviderOptions, qgrid as default };

package/dist/index.js

@@ -1000,6 +1000,27 @@ const GROK_MODEL_ID = /^grok\/[A-Za-z0-9._-]+$/;
 function assertGrokModelId(modelId, label) {
 	if (!GROK_MODEL_ID.test(modelId)) throw new Error(`${label}: unsupported model ${modelId}; expected grok/<id>`);
 }
+/** Voice factories accept `grok/<id>` and `openai/<id>`; everything else throws at creation. */
+function voiceProviderOf(modelId, label) {
+	if (GROK_MODEL_ID.test(modelId)) return "grok";
+	if (/^openai\/[A-Za-z0-9._-]+$/.test(modelId)) return "openai";
+	throw new Error(`${label}: unsupported model ${modelId}; expected grok/<id> or openai/<id>`);
+}
+const openaiQgridOptionsSchema = z.object({
+	tokenName: z.string().refine((value) => /^openai\/.+/.test(value.trim()), { message: "tokenName must be a non-empty OpenAI token name with the openai/ prefix" }).optional(),
+	logger: z.boolean({ message: "logger must be a boolean" }).optional()
+});
+/** `providerOptions.qgrid` for an `openai/` voice model: tokenName must carry the openai/ prefix. */
+function parseOpenAIQgridOptions(raw, label) {
+	if (raw === void 0) return {};
+	if (!providerOptionsObjectSchema.safeParse(raw).success) throw new Error(`${label}: providerOptions.qgrid must be an object`);
+	const parsed = openaiQgridOptionsSchema.safeParse(raw);
+	if (!parsed.success) throw new Error(`${label}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+	const request = {};
+	if (parsed.data.tokenName !== void 0) request.tokenName = parsed.data.tokenName;
+	if (parsed.data.logger === false) request.logger = false;
+	return request;
+}
 function formatMiB(bytes) {
 	return `${(bytes / 1024 / 1024).toFixed(2)} MiB`;
 }
@@ -1118,21 +1139,29 @@ function parseGrokQgridOptions(raw, label) {
 * `honored`. Malformed values throw; documented-but-unsupported keys become warnings.
 */
 function parseXaiMediaOptions(raw, schema, honored, label) {
+	return parseNamespacedMediaOptions("xai", raw, schema, honored, label);
+}
+/**
+* Validates `providerOptions.<namespace>` against the official provider's schema and warns for
+* every set key qgrid does not honor, so code written for `@ai-sdk/xai` or `@ai-sdk/openai`
+* keeps parsing and learns what was dropped.
+*/
+function parseNamespacedMediaOptions(namespace, raw, schema, honored, label) {
 	if (raw === void 0) return {
 		options: void 0,
 		warnings: []
 	};
 	const record = providerOptionsObjectSchema.safeParse(raw);
-	if (!record.success) throw new Error(`${label}: providerOptions.xai must be an object`);
+	if (!record.success) throw new Error(`${label}: providerOptions.${namespace} must be an object`);
 	const parsed = schema.safeParse(raw);
-	if (!parsed.success) throw new Error(`${label}: invalid providerOptions.xai: ${formatIssues(parsed.error)}`);
+	if (!parsed.success) throw new Error(`${label}: invalid providerOptions.${namespace}: ${formatIssues(parsed.error)}`);
 	const warnings = [];
 	for (const [key, value] of Object.entries(record.data)) {
 		if (value === void 0 || value === null || honored.has(key)) continue;
 		warnings.push({
 			type: "unsupported",
-			feature: `providerOptions.xai.${key}`,
-			details: `qgrid does not support providerOptions.xai.${key} for this model; it was ignored.`
+			feature: `providerOptions.${namespace}.${key}`,
+			details: `qgrid does not support providerOptions.${namespace}.${key} for this model; it was ignored.`
 		});
 	}
 	return {
@@ -1476,6 +1505,21 @@ const xaiSpeechOptionsSchema = z.object({
 	withTimestamps: z.boolean().nullish(),
 	replace: z.record(z.string(), z.string()).nullish()
 });
+/**
+* `providerOptions.openai` for OpenAI speech, field-for-field from `@ai-sdk/openai`
+* `openaiSpeechModelOptionsSchema` (vercel/ai fce9210). `instructions` is honored as style
+* guidance for the realtime model; `speed` warns.
+*/
+const openaiSpeechOptionsSchema = z.object({
+	instructions: z.string().nullish(),
+	speed: z.number().min(.25).max(4).nullish()
+});
+const OPENAI_SPEECH_HONORED = /* @__PURE__ */ new Set(["instructions"]);
+/** Realtime speech output: PCM16 24 kHz, as WAV (default) or raw PCM. */
+const OPENAI_SPEECH_FORMATS = ["wav", "pcm"];
+function isOpenAISpeechFormat(value) {
+	return OPENAI_SPEECH_FORMATS.some((format) => format === value);
+}
 const speakOutputSchema = z.object({
 	audio: z.string(),
 	mimeType: z.string(),
@@ -1495,8 +1539,9 @@ function base64ToBytes(data) {
 * `ara` / `en` / `mp3` (the only combination verified live). The model id only labels the log.
 */
 function createQgridSpeech(modelId, config) {
-	assertGrokModelId(modelId, LABEL$2);
+	const provider = voiceProviderOf(modelId, LABEL$2);
 	const { serverUrl, projectName } = resolveMediaConfig(config);
+	if (provider === "openai") return createOpenAISpeech(modelId, serverUrl, projectName);
 	return {
 		specificationVersion: "v3",
 		provider: QGRID_PROVIDER_NAME,
@@ -1570,6 +1615,89 @@ function createQgridSpeech(modelId, config) {
 		}
 	};
 }
+/**
+* OpenAI subscription speech: a realtime conversational model repeating the text verbatim (there
+* is no `gpt-4o-mini-tts` on subscription). Follows `@ai-sdk/openai` option names: `voice`
+* (default `marin`, Codex v2 list), `outputFormat` `wav` (default) or `pcm` — other formats
+* warn and fall back to wav, as the official provider falls back to mp3 — `openai.instructions`
+* as style guidance, `openai.speed` and `language` unsupported with the official warning text.
+*/
+function createOpenAISpeech(modelId, serverUrl, projectName) {
+	return {
+		specificationVersion: "v3",
+		provider: QGRID_PROVIDER_NAME,
+		modelId,
+		async doGenerate(options) {
+			if (!options.text.trim()) throw new Error(`${LABEL$2}: text must not be empty`);
+			if (options.text.length > MAX_TEXT_CHARS) throw new Error(`${LABEL$2}: text is limited to ${MAX_TEXT_CHARS} characters`);
+			const qgridOptions = parseOpenAIQgridOptions(options.providerOptions?.qgrid, LABEL$2);
+			const openai = parseNamespacedMediaOptions("openai", options.providerOptions?.openai, openaiSpeechOptionsSchema, OPENAI_SPEECH_HONORED, LABEL$2);
+			const warnings = [];
+			let format;
+			if (options.outputFormat !== void 0) {
+				if (isOpenAISpeechFormat(options.outputFormat)) format = options.outputFormat;
+				else {
+					format = "wav";
+					warnings.push({
+						type: "unsupported",
+						feature: "outputFormat",
+						details: `Unsupported output format: ${options.outputFormat}. Using wav instead.`
+					});
+				}
+			}
+			if (options.language !== void 0) warnings.push({
+				type: "unsupported",
+				feature: "language",
+				details: `OpenAI speech models do not support language selection. Language parameter "${options.language}" was ignored.`
+			});
+			if (options.speed !== void 0) warnings.push({
+				type: "unsupported",
+				feature: "speed"
+			});
+			warnings.push(...openai.warnings);
+			const requestParams = {
+				model: modelId,
+				text: options.text
+			};
+			if (options.voice !== void 0) requestParams.voice = options.voice;
+			if (format !== void 0) requestParams.format = format;
+			const instructions = options.instructions ?? openai.options?.instructions ?? void 0;
+			if (instructions !== void 0) requestParams.instructions = instructions;
+			if (projectName) requestParams.projectName = projectName;
+			const params = {
+				...requestParams,
+				...qgridOptions
+			};
+			const body = serializeMediaBody(params, LABEL$2);
+			const timestamp = /* @__PURE__ */ new Date();
+			const { data, headers } = await postMediaEndpoint({
+				serverUrl,
+				endpoint: "speak",
+				body,
+				schema: speakOutputSchema,
+				label: LABEL$2,
+				signal: options.abortSignal,
+				headers: options.headers
+			});
+			const qgridMetadata = {
+				mediaType: data.mimeType,
+				tokenName: data.tokenName
+			};
+			if (data.requestLogId !== void 0) qgridMetadata.requestLogId = data.requestLogId;
+			return {
+				audio: base64ToBytes(data.audio),
+				warnings,
+				request: { body: params },
+				response: {
+					timestamp,
+					modelId,
+					headers
+				},
+				providerMetadata: { qgrid: qgridMetadata }
+			};
+		}
+	};
+}
 //#endregion
 //#region src/transcription-model.ts
 const LABEL$1 = "qgrid.transcription";
@@ -1604,6 +1732,40 @@ const xaiTranscriptionOptionsSchema = z.object({
 	streaming: z.object({}).loose().optional()
 });
 const XAI_TRANSCRIPTION_HONORED = /* @__PURE__ */ new Set(["language"]);
+/**
+* `providerOptions.openai` for OpenAI transcription, field-for-field from `@ai-sdk/openai`
+* `openAITranscriptionModelOptions` (vercel/ai fce9210). The realtime transcription session
+* honors `language` and `prompt`; the rest warn.
+*/
+const openaiTranscriptionOptionsSchema = z.object({
+	include: z.array(z.string()).optional(),
+	language: z.string().optional(),
+	prompt: z.string().optional(),
+	temperature: z.number().min(0).max(1).optional(),
+	timestampGranularities: z.array(z.enum(["word", "segment"])).optional(),
+	responseFormat: z.enum([
+		"json",
+		"verbose_json",
+		"diarized_json"
+	]).optional(),
+	chunkingStrategy: z.union([z.literal("auto"), z.object({
+		type: z.literal("server_vad"),
+		threshold: z.number().min(0).max(1).optional(),
+		prefixPaddingMs: z.number().int().min(0).optional(),
+		silenceDurationMs: z.number().int().min(0).optional()
+	})]).optional(),
+	streaming: z.object({
+		delay: z.enum([
+			"minimal",
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]).optional(),
+		include: z.array(z.string()).optional()
+	}).optional()
+});
+const OPENAI_TRANSCRIPTION_HONORED = /* @__PURE__ */ new Set(["language", "prompt"]);
 const transcribeOutputSchema = z.object({
 	text: z.string(),
 	language: z.string().optional(),
@@ -1618,7 +1780,7 @@ function normalizeMediaType(mediaType) {
 	return bare;
 }
 function createQgridTranscription(modelId, config) {
-	assertGrokModelId(modelId, LABEL$1);
+	const provider = voiceProviderOf(modelId, LABEL$1);
 	const { serverUrl, projectName } = resolveMediaConfig(config);
 	return {
 		specificationVersion: "v3",
@@ -1629,16 +1791,24 @@ function createQgridTranscription(modelId, config) {
 			const audio = options.audio instanceof Uint8Array ? bytesToBase64(options.audio) : options.audio;
 			if (audio.length === 0) throw new Error(`${LABEL$1}: audio is empty`);
 			assertInlineMediaFits([audio], LABEL$1);
-			const qgridOptions = parseGrokQgridOptions(options.providerOptions?.qgrid, LABEL$1);
-			const xai = parseXaiMediaOptions(options.providerOptions?.xai, xaiTranscriptionOptionsSchema, XAI_TRANSCRIPTION_HONORED, LABEL$1);
-			const warnings = [...xai.warnings];
-			const language = xai.options?.language ?? void 0;
+			const qgridOptions = provider === "openai" ? parseOpenAIQgridOptions(options.providerOptions?.qgrid, LABEL$1) : parseGrokQgridOptions(options.providerOptions?.qgrid, LABEL$1);
+			const warnings = [];
 			const params = {
 				model: modelId,
 				audio,
 				mediaType
 			};
-			if (language !== void 0) params.language = language;
+			if (provider === "openai") {
+				const openai = parseNamespacedMediaOptions("openai", options.providerOptions?.openai, openaiTranscriptionOptionsSchema, OPENAI_TRANSCRIPTION_HONORED, LABEL$1);
+				warnings.push(...openai.warnings);
+				if (openai.options?.language !== void 0) params.language = openai.options.language;
+				if (openai.options?.prompt !== void 0) params.prompt = openai.options.prompt;
+			} else {
+				const xai = parseXaiMediaOptions(options.providerOptions?.xai, xaiTranscriptionOptionsSchema, XAI_TRANSCRIPTION_HONORED, LABEL$1);
+				warnings.push(...xai.warnings);
+				const language = xai.options?.language ?? void 0;
+				if (language !== void 0) params.language = language;
+			}
 			if (projectName) params.projectName = projectName;
 			const body = serializeMediaBody({
 				...params,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartanova/qgrid-ai-sdk",
-  "version": "2.15.3",
+  "version": "2.15.4",
   "description": "AI SDK LanguageModelV3 and ImageModelV3 provider for qgrid",
   "repository": {
     "type": "git",