@openwop/openwop-conformance 1.29.0 → 1.34.0

package/src/scenarios/voice-synthesis-streaming.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Streaming speech-synthesis arm (RFC 0106 §C) — behavioral.
+ *
+ * Gated on `capabilities.aiProviders.realtimeVoice.synthesis === 'streaming'`
+ * (root-first per RFC 0073). Soft-skips when unadvertised (default) / hard-fails
+ * under `OPENWOP_REQUIRE_BEHAVIOR=true`. Drives the documented host-sample seam
+ * `POST /v1/host/sample/ai/call-speech-synthesizer` with `stream: true`
+ * (soft-skips on 404 until a host wires it):
+ *
+ *   - returns 200 with the finalized RFC 0105 `audio` asset (EXACTLY ONE of
+ *     `url` / `base64`) — `stream: true` resolves the Promise at completion,
+ *     unchanged whole-file result shape;
+ *   - emits `voice.synthesis_chunk` run-events carrying METADATA ONLY
+ *     (`seq` + `mimeType`; bytes by `url`/`streamRef`, NOT inline base64 past
+ *     the host cap — the G8 event-log-bounded rule), with a terminal `final: true`.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0106-realtime-voice-session-profile.md (§C)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const SEAM = '/v1/host/sample/ai/call-speech-synthesizer';
+
+function realtimeVoiceOf(ai: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const rv = (ai as { realtimeVoice?: unknown })?.realtimeVoice;
+  return rv && typeof rv === 'object' ? (rv as Record<string, unknown>) : undefined;
+}
+function eventsOf(json: unknown): Array<{ type?: string; payload?: Record<string, unknown> }> {
+  const e = (json as { events?: unknown })?.events;
+  return Array.isArray(e) ? (e as Array<{ type?: string; payload?: Record<string, unknown> }>) : [];
+}
+
+describe('voice-synthesis-streaming (RFC 0106 §C)', () => {
+  it('stream:true resolves the finalized asset and emits metadata-only voice.synthesis_chunk events', async () => {
+    const ai = await readCapabilityFamily<Record<string, unknown>>('aiProviders');
+    const advertised = realtimeVoiceOf(ai)?.synthesis === 'streaming';
+    if (!behaviorGate('openwop-voice-synthesis', advertised)) return;
+
+    const res = await driver.post(SEAM, { text: 'Welcome to the weekly digest.', voiceId: 'host:narrator-test', stream: true });
+    if (res.status === 404) return; // seam unwired — soft-skip
+
+    expect(
+      res.status === 200,
+      driver.describe('RFC 0106 §C', 'an advertised host MUST resolve stream:true with 200'),
+    ).toBe(true);
+
+    const audio = (res.json as { audio?: Record<string, unknown> })?.audio;
+    expect(audio !== undefined, driver.describe('RFC 0106 §C', 'the response MUST carry the finalized `audio` asset')).toBe(true);
+    if (audio) {
+      const hasUrl = typeof audio.url === 'string' && (audio.url as string).length > 0;
+      const hasB64 = typeof audio.base64 === 'string' && (audio.base64 as string).length > 0;
+      expect(hasUrl !== hasB64, driver.describe('RFC 0106 §C', 'audio MUST carry EXACTLY ONE of url/base64')).toBe(true);
+    }
+
+    const chunks = eventsOf(res.json).filter((e) => e.type === 'voice.synthesis_chunk');
+    expect(chunks.length >= 1, driver.describe('RFC 0106 §C', 'MUST emit ≥1 voice.synthesis_chunk run-event')).toBe(true);
+    for (const c of chunks) {
+      const p = c.payload ?? {};
+      expect(typeof p.seq === 'number', driver.describe('RFC 0106 §C', 'each chunk carries a numeric seq')).toBe(true);
+      expect(typeof p.mimeType === 'string', driver.describe('RFC 0106 §C', 'each chunk carries a mimeType')).toBe(true);
+      // Metadata-only: bytes by reference. An inline base64 is permitted ONLY under the host cap;
+      // a chunk over the RFC 0055 256 KiB inline cap MUST be a url/streamRef reference.
+      if (typeof p.base64 === 'string') {
+        expect((p.base64 as string).length <= 262144, driver.describe('RFC 0106 §C (G8)', 'inline chunk base64 MUST stay under the 256 KiB cap; else url/streamRef')).toBe(true);
+      }
+    }
+    expect(
+      chunks.some((c) => (c.payload ?? {}).final === true),
+      driver.describe('RFC 0106 §C', 'a terminal chunk MUST carry final:true'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/voice-transcription-streaming.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Streaming transcription round-trip (RFC 0106 §B) — behavioral.
+ *
+ * Gated on `capabilities.aiProviders.realtimeVoice.transcription === 'streaming'`.
+ * Soft-skips when unadvertised (default) / hard-fails under
+ * `OPENWOP_REQUIRE_BEHAVIOR=true`. Drives `POST /v1/host/sample/ai/call-transcriber`
+ * (soft-skips on 404 and on `transcription_unsupported` — a host whose live-stream
+ * transport is host-internal per §E honestly rejects a `streamRef`, so the
+ * non-vacuous turn requires the deterministic test-seam arm
+ * (`OPENWOP_TEST_SEAM_ENABLED`) or a finalized media asset):
+ *
+ *   - resolves with the settled turn (`finalText`, non-empty) at `voice.turn_commit`;
+ *   - any emitted `voice.transcript` carries `contentTrust: "untrusted"` (§F);
+ *   - the turn terminates with `voice.turn_commit`.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0106-realtime-voice-session-profile.md (§B, §F)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const SEAM = '/v1/host/sample/ai/call-transcriber';
+
+function realtimeVoiceOf(ai: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const rv = (ai as { realtimeVoice?: unknown })?.realtimeVoice;
+  return rv && typeof rv === 'object' ? (rv as Record<string, unknown>) : undefined;
+}
+function errCode(json: unknown): string | undefined {
+  return (json as { error?: { code?: string } })?.error?.code;
+}
+function eventsOf(json: unknown): Array<{ type?: string; payload?: Record<string, unknown> }> {
+  const e = (json as { events?: unknown })?.events;
+  return Array.isArray(e) ? (e as Array<{ type?: string; payload?: Record<string, unknown> }>) : [];
+}
+
+describe('voice-transcription-streaming (RFC 0106 §B)', () => {
+  it('resolves a settled turn at voice.turn_commit with untrusted transcript events', async () => {
+    const ai = await readCapabilityFamily<Record<string, unknown>>('aiProviders');
+    const advertised = realtimeVoiceOf(ai)?.transcription === 'streaming';
+    if (!behaviorGate('openwop-voice-transcription', advertised)) return;
+
+    const res = await driver.post(SEAM, { audio: { streamRef: 'stream:conformance/mic' }, languageCode: 'en-US' });
+    if (res.status === 404) return; // seam unwired — soft-skip
+    // §E: a stateless host with no live transport honestly rejects a live streamRef.
+    if (errCode(res.json) === 'transcription_unsupported') return; // soft-skip (no live transport / no test-seam arm)
+
+    expect(res.status === 200, driver.describe('RFC 0106 §B', 'a produced turn MUST return 200')).toBe(true);
+
+    const finalText = (res.json as { finalText?: unknown })?.finalText;
+    expect(typeof finalText === 'string' && (finalText as string).length > 0, driver.describe('RFC 0106 §B', 'the turn MUST resolve a non-empty finalText at turn_commit')).toBe(true);
+
+    const events = eventsOf(res.json);
+    if (events.length > 0) {
+      for (const ev of events.filter((e) => e.type === 'voice.transcript')) {
+        expect((ev.payload ?? {}).contentTrust === 'untrusted', driver.describe('RFC 0106 §F INV-2', 'every voice.transcript MUST carry contentTrust:"untrusted"')).toBe(true);
+      }
+      expect(events.some((e) => e.type === 'voice.turn_commit'), driver.describe('RFC 0106 §B', 'the turn MUST terminate with voice.turn_commit')).toBe(true);
+    }
+  });
+});

package/src/scenarios/voice-transcription-unadvertised.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Streaming transcription on an unadvertising host (RFC 0106 §B) — behavioral.
+ *
+ * Gated by ABSENCE: active precisely when `realtimeVoice.transcription` is NOT
+ * advertised but the seam exists. Soft-skips otherwise (default) / hard-fails
+ * under `OPENWOP_REQUIRE_BEHAVIOR=true`. A host that does NOT advertise streaming
+ * transcription MUST reject `ctx.callTranscriber` with `transcription_unsupported`
+ * (never a 200 success, never a silent no-op) — paralleling RFC 0105's
+ * `speech_synthesis_unsupported` / RFC 0091's `unsupported_modality`.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0106-realtime-voice-session-profile.md (§B)
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders Failure modes)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { behaviorGate } from '../lib/behavior-gate.js';
+import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
+
+const SEAM = '/v1/host/sample/ai/call-transcriber';
+
+function realtimeVoiceOf(ai: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const rv = (ai as { realtimeVoice?: unknown })?.realtimeVoice;
+  return rv && typeof rv === 'object' ? (rv as Record<string, unknown>) : undefined;
+}
+function errCode(json: unknown): string | undefined {
+  return (json as { error?: { code?: string } })?.error?.code;
+}
+
+describe('voice-transcription-unadvertised (RFC 0106 §B)', () => {
+  it('a host NOT advertising realtimeVoice.transcription MUST reject with transcription_unsupported', async () => {
+    const ai = await readCapabilityFamily<Record<string, unknown>>('aiProviders');
+    const advertised = realtimeVoiceOf(ai)?.transcription === 'streaming';
+    if (!behaviorGate('openwop-voice-transcription-unadvertised', !advertised)) return;
+
+    const res = await driver.post(SEAM, { audio: { streamRef: 'stream:conformance/mic' } });
+    if (res.status === 404) return; // seam unwired — soft-skip
+
+    expect(res.status !== 200, driver.describe('RFC 0106 §B', 'an unadvertising host MUST NOT return a 200 (never a no-op)')).toBe(true);
+    expect(
+      errCode(res.json) === 'transcription_unsupported',
+      driver.describe('RFC 0106 §B', 'the call MUST be rejected with `transcription_unsupported`'),
+    ).toBe(true);
+  });
+});