@openwop/openwop-conformance 1.28.0 → 1.33.0

package/schemas/conversation-turn.schema.json

@@ -66,7 +66,42 @@
       "type": "integer",
       "minimum": 0,
       "description": "0-based index within the conversation. `conversation.opened.initialTurn` carries `turnIndex: 0`; subsequent `conversation.exchanged` turns increment monotonically; `conversation.closed.finalTurn` carries the highest index."
+    },
+    "speakerId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 256,
+      "description": "RFC 0101. Stable speaker identity of this turn — the roster INSTANCE id of the agent that produced it (the `host:<id>` AgentRef agentId per `agent-roster-entry.schema.json` §A / RFC 0086), NOT the manifest/class `AgentRef.agentId`. REQUIRED when `role: 'agent'` (the conditional below) so that 'turn N was spoken by agent X' is an observable, replay-stable, cross-host-projectable fact in a multi-party transcript. When a `participants` roster is declared on `conversation.opened` (RFC 0101), `speakerId` MUST be a member of that roster; a turn whose `speakerId` is not a participant MUST be rejected (host-enforced, capability-gated on `multiPartyConversation.supported`). For `role: 'user'` / `role: 'system'` turns the field is OPTIONAL and carries no normative meaning. Additive-safe: pre-RFC-0101 `role: 'agent'` turns that omit it are accepted by hosts that do NOT advertise `multiPartyConversation`."
     }
   },
+  "allOf": [
+    {
+      "$comment": "RFC 0101 — agent turns MUST carry speaker attribution. Conditional (not unconditional `required`) so the field is only mandatory for `role: 'agent'`; `user`/`system` turns and pre-RFC-0101 producers on non-multi-party hosts are unaffected. Capability-gated: hosts enforce this only when advertising `multiPartyConversation.supported` (capabilities.schema.json).",
+      "if": { "properties": { "role": { "const": "agent" } }, "required": ["role"] },
+      "then": { "required": ["speakerId"] }
+    }
+  ],
+  "examples": [
+    {
+      "$comment": "RFC 0101 POSITIVE — an agent turn in a multi-party council carrying speaker attribution (the roster instance id).",
+      "messageId": "council-q1:1:agent",
+      "from": "host:advisor-cfo",
+      "content": "From a cash-runway view I'd push the launch one quarter.",
+      "ts": 1718900000000,
+      "role": "agent",
+      "turnIndex": 1,
+      "speakerId": "host:advisor-cfo"
+    },
+    {
+      "$comment": "RFC 0101 POSITIVE — a user turn; speakerId is OPTIONAL for non-agent roles and omitted here.",
+      "messageId": "council-q1:0:user",
+      "from": "user",
+      "content": "Should we launch in Q3 or Q4?",
+      "ts": 1718900000000,
+      "role": "user",
+      "turnIndex": 0
+    }
+  ],
+  "$comment": "RFC 0101 NEGATIVE (covered by the `allOf`/`if` conditional + conversation scenarios, NOT validatable as an `examples[]` entry which must be VALID): a `{ role: 'agent', ... }` turn that OMITS `speakerId` MUST FAIL validation; see conformance/src/scenarios/multi-party-conversation-shape.test.ts.",
   "additionalProperties": true
 }

package/schemas/registry-version-manifest.schema.json

@@ -4,10 +4,26 @@
   "title": "RegistryVersionManifest",
   "description": "Registry-augmented version manifest served at `/v1/packs/{name}/-/{version}.json`. Extends the bare pack manifest (`node-pack-manifest.schema.json`) with registry-side metadata (integrity hash, publishedAt timestamp, signed-blob URLs, lifecycle flags). This is the shape clients receive when they GET a specific pack version; the bare manifest is what publishers commit inside the tarball.\n\n**Why two schemas?** The bare manifest is the authoring contract — what a vendor writes in their pack source tree. The registry-augmented version is the SERVING contract — what `packs.openwop.dev` produces after `build-index.mjs` computes integrity hashes + adds URL templates. Validating both surfaces independently catches drift between authored content and served metadata.",
   "type": "object",
-  "required": ["name", "version", "engines", "runtime", "integrity"],
+  "required": ["name", "version", "engines", "integrity"],
   "anyOf": [
     { "properties": { "nodes": { "type": "array", "minItems": 1 } }, "required": ["nodes"] },
-    { "properties": { "agents": { "type": "array", "minItems": 1 } }, "required": ["agents"] }
+    { "properties": { "agents": { "type": "array", "minItems": 1 } }, "required": ["agents"] },
+    { "properties": { "artifactTypes": { "type": "array", "minItems": 1 } }, "required": ["artifactTypes"] },
+    { "required": ["provider"] },
+    { "properties": { "chains": { "type": "array", "minItems": 1 } }, "required": ["chains"] },
+    { "properties": { "prompts": { "type": "array", "minItems": 1 } }, "required": ["prompts"] },
+    { "properties": { "cards": { "type": "array", "minItems": 1 } }, "required": ["cards"] }
+  ],
+  "allOf": [
+    {
+      "$comment": "RFC 0107 — runtime is required for EXECUTABLE kinds (node, or kind absent) and MUST be absent for DECLARATIVE kinds (artifact-type, connection, workflow-chain, prompt, chat-card).",
+      "if": {
+        "properties": { "kind": { "enum": ["artifact-type", "connection", "workflow-chain", "prompt", "chat-card"] } },
+        "required": ["kind"]
+      },
+      "then": { "not": { "required": ["runtime"] } },
+      "else": { "required": ["runtime"] }
+    }
   ],
   "properties": {
     "name": {
@@ -40,6 +56,37 @@
       },
       "additionalProperties": { "type": "string" }
     },
+    "kind": {
+      "type": "string",
+      "enum": ["node", "artifact-type", "connection", "workflow-chain", "prompt", "chat-card"],
+      "default": "node",
+      "description": "Pack-kind discriminator (RFC 0107). ABSENT ≡ `node` (the original, executable kind — backward compatible). Executable kinds (`node`) carry `runtime` + `nodes[]`/`agents[]`. DECLARATIVE kinds carry their own payload and NO `runtime`: `artifact-type` → `artifactTypes[]` (RFC 0075); `connection` → `provider` (RFC 0095); `workflow-chain` → `chains[]` (RFC 0013); `prompt` → `prompts[]`; `chat-card` → `cards[]`. The registry's runtime-support check (registry-operations.md §Validation flow #7) is skipped for declarative kinds."
+    },
+    "artifactTypes": {
+      "type": "array",
+      "description": "Present iff `kind == \"artifact-type\"` (RFC 0075). Mirrors `artifact-type-pack-manifest.schema.json` `artifactTypes[]` (each: `artifactTypeId`, `title`, `schema`, `export[]`). Carried loosely here (the source schema is authoritative); the registry denormalizes `artifactTypes[].artifactTypeId` into the per-pack index for discovery.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "provider": {
+      "type": "object",
+      "description": "Present iff `kind == \"connection\"` (RFC 0095). Mirrors `connection-pack-manifest.schema.json` `provider` (id, category, auth, reach, …). MUST NOT carry credential material (RFC 0095 §B.2 — enforced at source; a registry SHOULD re-scan). The registry denormalizes `provider.id` into the per-pack index.",
+      "additionalProperties": true
+    },
+    "chains": {
+      "type": "array",
+      "description": "Present iff `kind == \"workflow-chain\"` (RFC 0013). Carried loosely (the source schema is authoritative); the registry denormalizes `chains[].chainId` into the per-pack index.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "prompts": {
+      "type": "array",
+      "description": "Present iff `kind == \"prompt\"`. Carried loosely; source schema authoritative.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
+    "cards": {
+      "type": "array",
+      "description": "Present iff `kind == \"chat-card\"`. Carried loosely; source schema authoritative.",
+      "items": { "type": "object", "additionalProperties": true }
+    },
     "runtime": {
       "type": "object",
       "required": ["language"],

package/schemas/run-event-payloads.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://openwop.dev/spec/v1/run-event-payloads.schema.json",
   "title": "RunEventPayloads",
-  "description": "Per-RunEventType payload schemas. The base RunEventDoc shape (run-event.schema.json) leaves `payload` permissive for forward-compat. This schema defines the canonical payload contract for each known RunEventType. Consumers MAY pin strict payload validation via `$defs.<typeId>` and `ajv.validate(schema.$defs[event.type], event.payload)`. Unknown event types MUST be tolerated (no $defs match → fold best-effort).\n\n100 variants from `run-event.schema.json#$defs.RunEventType` are covered, grouped into ~20 shape families with shared $defs. Naming convention: camelCase keys mirror dotted RunEventType names (e.g., `run.started` → `runStarted`).",
+  "description": "Per-RunEventType payload schemas. The base RunEventDoc shape (run-event.schema.json) leaves `payload` permissive for forward-compat. This schema defines the canonical payload contract for each known RunEventType. Consumers MAY pin strict payload validation via `$defs.<typeId>` and `ajv.validate(schema.$defs[event.type], event.payload)`. Unknown event types MUST be tolerated (no $defs match → fold best-effort).\n\n107 variants from `run-event.schema.json#$defs.RunEventType` are covered, grouped into ~20 shape families with shared $defs. Naming convention: camelCase keys mirror dotted RunEventType names (e.g., `run.started` → `runStarted`).",
   "type": "object",
   "$defs": {
     "_typeIndex": {
@@ -109,10 +109,95 @@
         "proposal.activated":        { "$ref": "#/$defs/proposalActivated" },
         "goal.evaluated":            { "$ref": "#/$defs/goalEvaluated" },
         "goal.closed":               { "$ref": "#/$defs/goalClosed" },
-        "import.applied":            { "$ref": "#/$defs/importApplied" }
+        "import.applied":            { "$ref": "#/$defs/importApplied" },
+        "voice.speech_start":        { "$ref": "#/$defs/voiceSpeechStart" },
+        "voice.transcript":          { "$ref": "#/$defs/voiceTranscript" },
+        "voice.endpoint_candidate":  { "$ref": "#/$defs/voiceEndpointCandidate" },
+        "voice.turn_commit":         { "$ref": "#/$defs/voiceTurnCommit" },
+        "voice.synthesis_chunk":     { "$ref": "#/$defs/voiceSynthesisChunk" },
+        "voice.barge_in":            { "$ref": "#/$defs/voiceBargeIn" },
+        "voice.cancelled":           { "$ref": "#/$defs/voiceCancelled" }
       }
     },
 
+    "voiceSpeechStart": {
+      "description": "RFC 0106 §D. Emitted when inbound user speech onset is detected in a live voice session. Content-free (a timestamp only). MUST NOT be emitted unless `aiProviders.realtimeVoice.transcription: \"streaming\"` is advertised.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0, "description": "Session-relative onset timestamp (ms)." }
+      }
+    },
+    "voiceTranscript": {
+      "description": "RFC 0106 §B/§D. A settled or provisional transcript part for the current turn, emitted on the durable event log as the single canonical record (the `ctx.callTranscriber` Promise resolves separately at `turn_commit`). `text` is the recognized speech — UNTRUSTED input (anyone in acoustic range is an unauthenticated writer): it MUST carry `contentTrust: \"untrusted\"` and MUST NOT be promoted to system/developer authority (SECURITY invariant `voice-transcript-untrusted`). A part with `isFinal: false` is provisional and MUST NOT be persisted to durable memory / the replay log / RAG or drive a side-effecting tool call before it finalizes (`voice-interim-not-durable`).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["text", "isFinal", "atMs", "contentTrust"],
+      "properties": {
+        "text": { "type": "string", "description": "The current hypothesis for this segment (editable tail when `isFinal:false`)." },
+        "isFinal": { "type": "boolean", "description": "true ⇒ this segment's text is settled and will not change." },
+        "committedPrefix": { "type": "string", "description": "The leading portion the host guarantees will not change (Deepgram/Web-Speech model)." },
+        "stability": { "type": "number", "minimum": 0, "maximum": 1, "description": "Graded tail confidence (Google `stability`); omit/1.0 for immutable ASR." },
+        "formatted": { "type": "boolean", "description": "Punctuation/casing/ITN applied; absent ⇒ raw." },
+        "atMs": { "type": "integer", "minimum": 0 },
+        "contentTrust": { "const": "untrusted", "description": "MUST be `\"untrusted\"` — live transcript is untrusted ingress (`voice-transcript-untrusted`); never promote to higher authority." }
+      }
+    },
+    "voiceEndpointCandidate": {
+      "description": "RFC 0106 §B/§D. A silence boundary / likely end-of-turn appeared (only when `turnDetection: \"semantic\"`), DISTINCT from `voice.turn_commit` (Deepgram `UtteranceEnd` vs `speech_final`). Content-free.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1, "description": "Optional end-of-turn confidence." }
+      }
+    },
+    "voiceTurnCommit": {
+      "description": "RFC 0106 §B/§D. The user yielded the floor (turn boundary). This is where the `ctx.callTranscriber` Promise resolves. `finalText` is the settled transcript and is UNTRUSTED (it inherits the `voice.transcript` boundary).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs", "finalText"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "finalText": { "type": "string", "description": "The settled transcript for the committed turn (untrusted input)." }
+      }
+    },
+    "voiceSynthesisChunk": {
+      "description": "RFC 0106 §C. Announces a clause-boundary streaming-synthesis chunk. METADATA ONLY — the audio bytes are referenced by a session-scoped `streamRef`/`url`, NOT inlined on the event log past the host's inline cap (RFC 0055 256 KiB precedent; spill to a tenant-scoped `url`), so replay/`:fork` stays bounded over long sessions. MUST NOT be emitted unless `aiProviders.realtimeVoice.synthesis: \"streaming\"` is advertised.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["seq", "mimeType"],
+      "properties": {
+        "seq": { "type": "integer", "minimum": 0, "description": "Monotonic chunk sequence." },
+        "mimeType": { "type": "string", "minLength": 1, "description": "Audio chunk type (e.g. `audio/mpeg`)." },
+        "durationMs": { "type": "integer", "minimum": 0, "description": "Optional chunk duration." },
+        "url": { "type": "string", "description": "Tenant-scoped, SSRF-guarded (RFC 0076) reference to the chunk bytes." },
+        "streamRef": { "type": "string", "description": "Session-scoped live-stream handle for the chunk bytes." },
+        "base64": { "type": "string", "description": "OPTIONAL inline bytes, permitted ONLY while under the host's inline cap; past the cap the host MUST use `url`/`streamRef`." },
+        "final": { "type": "boolean", "description": "true on the terminal chunk." }
+      }
+    },
+    "voiceBargeIn": {
+      "description": "RFC 0106 §D. User speech overlapped active assistant playback (probable cut-in). A host advertising `realtimeVoice.bargeIn: \"supported\"` MUST emit this on detected overlap. Content-free. Distinct from `voice.cancelled` (a backchannel \"uh-huh\" MAY produce `barge_in` with no `cancelled`).",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "voiceCancelled": {
+      "description": "RFC 0106 §D. Downstream LLM/TTS work was cancelled (barge-in or explicit). A cancellation MUST NOT emit partial tool outputs or partial un-guardrailed model output and MUST roll back or fully complete an in-flight side effect (SECURITY invariant `voice-bargein-no-partial-leak`). Content-free.",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["atMs"],
+      "properties": {
+        "atMs": { "type": "integer", "minimum": 0 },
+        "reason": { "type": "string", "enum": ["barge-in", "explicit"], "description": "Why downstream work was cancelled." }
+      }
+    },
     "authorizationDecided": {
       "description": "RFC 0049 — emitted on a role-based authorization decision (allow or deny). Redaction-safe: `principal` is an opaque RFC 0048 id; `reason` carries no credential material. Every deny SHOULD be emitted and SHOULD feed the audit log (RFC 0009/0010). MUST NOT be emitted unless `capabilities.authorization.supported: true`.",
       "type": "object",

package/schemas/run-event.schema.json

@@ -171,7 +171,14 @@
         "proposal.activated",
         "goal.evaluated",
         "goal.closed",
-        "import.applied"
+        "import.applied",
+        "voice.speech_start",
+        "voice.transcript",
+        "voice.endpoint_candidate",
+        "voice.turn_commit",
+        "voice.synthesis_chunk",
+        "voice.barge_in",
+        "voice.cancelled"
       ]
     }
   }

package/src/lib/multi-agent-capabilities.ts

@@ -1,10 +1,14 @@
 /**
  * Multi-Agent Shift capability-gating helper.
  *
- * Reads the host's `/.well-known/openwop` `capabilities.agents` block
- * + `capabilities.conversationPrimitive` flag at suite init and caches
- * them as discrete predicates. Sibling to `lib/fixtures.ts` — same
- * pattern, different surface.
+ * Reads the host's `/.well-known/openwop` `agents` block + the
+ * `conversationPrimitive` flag — both at the document ROOT (RFC 0073
+ * root-first; `setMultiAgentCapabilities` reads `body.agents` /
+ * `body.conversationPrimitive`, NOT a nested `.capabilities` object) —
+ * at suite init and caches them as discrete predicates. A host that
+ * advertises these only under a `.capabilities` wrapper resolves to
+ * `false` and its gated scenarios skip vacuously. Sibling to
+ * `lib/fixtures.ts` — same pattern, different surface.
  *
  * Why: Multi-Agent Shift scenarios (Phases 1-6) gate on per-phase
  * capability flags. Mirrors the fixture-gating pattern from RFC 0003
@@ -46,6 +50,7 @@ interface AgentCaps {
 
 let _agentCaps: AgentCaps | null = null;
 let _conversationPrimitive = false;
+let _multiPartyConversation = false;
 
 function asBoolean(value: unknown): boolean {
   return value === true;
@@ -68,6 +73,7 @@ export function setMultiAgentCapabilities(c: DiscoveryPayload | null | undefined
   if (!c || typeof c !== 'object') {
     _agentCaps = null;
     _conversationPrimitive = false;
+    _multiPartyConversation = false;
     return;
   }
 
@@ -105,6 +111,12 @@ export function setMultiAgentCapabilities(c: DiscoveryPayload | null | undefined
   }
 
   _conversationPrimitive = asBoolean((c as { conversationPrimitive?: unknown }).conversationPrimitive);
+
+  // RFC 0101 — root-first read of the `multiPartyConversation` block (sibling
+  // of `conversationPrimitive`), matching the root-first convention above.
+  const mpcRaw = (c as { multiPartyConversation?: unknown }).multiPartyConversation;
+  _multiPartyConversation =
+    !!mpcRaw && typeof mpcRaw === 'object' && asBoolean((mpcRaw as Record<string, unknown>).supported);
 }
 
 /** Phase 1 master switch. */
@@ -143,6 +155,12 @@ export function isConversationPrimitiveSupported(): boolean {
   return _conversationPrimitive;
 }
 
+/** RFC 0101 — host enforces the multi-party group-conversation roster +
+ *  speaker-attribution contract (`multiPartyConversation.supported: true`). */
+export function isMultiPartyConversationSupported(): boolean {
+  return _multiPartyConversation;
+}
+
 /** Phase 5 — host implements `core.orchestrator.supervisor` + CP-1. */
 export function isOrchestratorSupported(): boolean {
   return _agentCaps?.orchestrator === true;
@@ -162,4 +180,5 @@ export function getCachedAgentCaps(): AgentCaps | null {
 export function __resetForTests(): void {
   _agentCaps = null;
   _conversationPrimitive = false;
+  _multiPartyConversation = false;
 }

package/src/lib/multiPartyConversation.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared helpers for the RFC 0101 multi-party group-conversation behavioral
+ * scenario. Lives in lib/ (not a `*.test.ts`) so scenarios import it via
+ * `../lib/multiPartyConversation.js`.
+ *
+ * RFC 0101 standardizes the multi-party *shape* (a `participants` roster on
+ * `conversation.opened` + a REQUIRED-for-agent-turns `speakerId` + the
+ * `multiPartyConversation` capability) but mints NO normative client wire-route
+ * to *open* a conversation — opening, turn order, and round protocol are
+ * non-normative host product policy (RFC 0101 §"Non-normative product policy").
+ * A conformance driver therefore initiates a council and submits turns via the
+ * conformance-only **multi-party conversation test seam**
+ * (`POST /v1/host/sample/conversation/multi-party/{open,exchange}`,
+ * `host-sample-test-seams.md` §"Open seams") — the same `/v1/host/sample/*`
+ * convention every other capability-gated behavioral leg uses. The seam routes
+ * through the SAME roster-membership + attribution enforcement the host applies
+ * on its production conversation path; it is OPTIONAL and self-contained
+ * (it does NOT require the host to implement the full RFC 0005 conversation
+ * gate). Scenarios soft-skip on `404`/`405`.
+ *
+ * @see RFCS/0101-multi-party-group-conversation.md (§Spec / §Conformance)
+ * @see spec/v1/host-sample-test-seams.md (multi-party conversation seam)
+ * @see RFCS/0005-conversation.md §E (turn-validation rejection — validation_error)
+ */
+import { driver } from './driver.js';
+import { readCapabilityFamily } from './discovery-capabilities.js';
+
+/** A slim AgentRef the seam accepts in a participant roster (mirror of
+ *  `agent-ref.schema.json`; only `agentId` is load-bearing for membership). */
+export interface SeamAgentRef {
+  agentId: string;
+  name?: string;
+}
+
+/** A conversation turn as the seam accepts it (subset of
+ *  `conversation-turn.schema.json` + the RFC 0101 `speakerId`). */
+export interface SeamTurn {
+  messageId: string;
+  from: string;
+  content: string;
+  ts: number;
+  role: 'user' | 'agent' | 'system';
+  turnIndex: number;
+  speakerId?: string;
+  [k: string]: unknown;
+}
+
+export interface MultiPartyConversationCap {
+  supported?: boolean;
+  maxParticipants?: number;
+  [k: string]: unknown;
+}
+
+/** Reads the root-first `multiPartyConversation` capability block from
+ *  discovery (RFC 0073 root-first); null when unadvertised. */
+export async function readMultiPartyCap(): Promise<MultiPartyConversationCap | null> {
+  const mpc = await readCapabilityFamily<MultiPartyConversationCap>('multiPartyConversation');
+  return mpc && typeof mpc === 'object' ? mpc : null;
+}
+
+export interface SeamResult {
+  /** HTTP status. `0` when the seam is unwired (404/405 → soft-skip sentinel). */
+  status: number;
+  /** Decoded JSON body, when present. */
+  body: Record<string, unknown> | undefined;
+  /** True when the seam is absent (404/405) — caller soft-skips. */
+  unwired: boolean;
+}
+
+function toResult(res: { status: number; json: unknown }): SeamResult {
+  const unwired = res.status === 404 || res.status === 405;
+  return {
+    status: res.status,
+    body: res.json && typeof res.json === 'object' ? (res.json as Record<string, unknown>) : undefined,
+    unwired,
+  };
+}
+
+/** Open a multi-party council via the conformance seam. Returns `unwired:true`
+ *  on 404/405 so the scenario soft-skips. NOTE: a `validation_error` rejection
+ *  (e.g. roster exceeds maxParticipants) is a REAL 400/422 result, NOT unwired —
+ *  only 404/405 mean the seam is absent. */
+export async function openMultiPartyConversation(body: {
+  conversationId: string;
+  participants: SeamAgentRef[];
+  maxParticipants?: number;
+}): Promise<SeamResult> {
+  const res = await driver.post('/v1/host/sample/conversation/multi-party/open', body);
+  return toResult(res);
+}
+
+/** Submit one turn to an open council via the conformance seam. */
+export async function exchangeMultiPartyTurn(body: {
+  conversationId: string;
+  turn: SeamTurn;
+}): Promise<SeamResult> {
+  const res = await driver.post('/v1/host/sample/conversation/multi-party/exchange', body);
+  return toResult(res);
+}
+
+/** The canonical `error.code` an RFC 0101 rejection carries (RFC 0005 §E).
+ *  Tolerant of both `{ error: { code } }` and `{ error: '<code>' }` shapes. */
+export function errorCodeOf(body: Record<string, unknown> | undefined): string | undefined {
+  if (!body) return undefined;
+  const err = body.error;
+  if (typeof err === 'string') return err;
+  if (err && typeof err === 'object') {
+    const code = (err as Record<string, unknown>).code;
+    if (typeof code === 'string') return code;
+  }
+  const code = body.code;
+  return typeof code === 'string' ? code : undefined;
+}
+
+/** A rejection is RFC-0101-conformant when the status is a client error
+ *  (`400`/`422` — RFC 0005 §E pins the code, not the status) AND the body
+ *  carries `error.code === 'validation_error'`. */
+export function isValidationErrorRejection(r: SeamResult): boolean {
+  const clientError = r.status === 400 || r.status === 422;
+  return clientError && errorCodeOf(r.body) === 'validation_error';
+}

package/src/scenarios/aiproviders-realtimevoice-shape.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Real-time voice capability advertisement shape (RFC 0106 §A) — server-free.
+ *
+ * Always-on schema-shape probe for the RFC 0106 real-time voice profile. Verifies that:
+ *   - `capabilities.aiProviders.realtimeVoice` is an OBJECT sibling of `speechSynthesis`/
+ *     `input` in the `aiProviders` block, with the sub-flags `transcription`
+ *     (const `"streaming"`), `synthesis` (const `"streaming"`), `turnDetection`
+ *     (enum `vad|semantic`), and `bargeIn` (const `"supported"`).
+ *   - `realtimeVoice` is NOT in `aiProviders.required`: absence is the default (a host
+ *     WITHOUT live voice is a valid discovery doc).
+ *   - the §A closures hold via Ajv2020: `turnDetection`/`bargeIn` imply `transcription`
+ *     (`dependentRequired`), and `realtimeVoice.synthesis` implies
+ *     `aiProviders.speechSynthesis` (the if/then on the `aiProviders` block).
+ *
+ * Behavioral assertions (the live `ctx.callTranscriber` Promise-resolves-at-turn_commit
+ * + `voice.*` emission; the unadvertised-host reject; the streaming synthesis arm) are
+ * gated on `aiProviders.realtimeVoice.{transcription,synthesis}` and live in the gated
+ * `voice-transcription-streaming.test.ts` / `voice-transcription-unadvertised.test.ts` /
+ * `voice-synthesis-streaming.test.ts` scenarios. This scenario asserts the wire contract,
+ * not host behavior.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0106-realtime-voice-session-profile.md (§A, §B)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+/** Server-free assertion-message helper. */
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+
+function loadSchema(name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+}
+
+function aiProvidersSchema(): Record<string, unknown> {
+  const caps = loadSchema('capabilities.schema.json');
+  return (caps.properties as Record<string, Record<string, unknown>>).aiProviders;
+}
+
+describe('aiproviders-realtimevoice-shape: capability advertisement (RFC 0106 §A, server-free)', () => {
+  it('aiProviders.realtimeVoice is an object with the four sub-flags', () => {
+    const realtimeVoice = (aiProvidersSchema().properties as Record<string, { type?: unknown; properties?: Record<string, unknown> }>)
+      .realtimeVoice;
+    expect(
+      realtimeVoice,
+      why('host-capabilities.md §host.aiProviders', 'aiProviders.realtimeVoice MUST be declared'),
+    ).toBeDefined();
+    expect(realtimeVoice?.type, why('RFC 0106 §A', 'realtimeVoice MUST be an object')).toBe('object');
+    const props = realtimeVoice?.properties ?? {};
+    for (const flag of ['transcription', 'synthesis', 'turnDetection', 'bargeIn']) {
+      expect(
+        Object.prototype.hasOwnProperty.call(props, flag),
+        why('RFC 0106 §A', `realtimeVoice.${flag} MUST be declared`),
+      ).toBe(true);
+    }
+  });
+
+  it('realtimeVoice is NOT in aiProviders.required — absence (no live voice) is a valid default', () => {
+    const aiProviders = aiProvidersSchema() as { required?: unknown };
+    const required = Array.isArray(aiProviders.required) ? (aiProviders.required as string[]) : [];
+    expect(
+      required.includes('realtimeVoice'),
+      why('RFC 0106 §A', 'aiProviders.realtimeVoice MUST be optional (a host without live voice is valid)'),
+    ).toBe(false);
+  });
+
+  it('Ajv: the realtimeVoice subschema accepts the floor and enforces the turnDetection/bargeIn ⇒ transcription closure', () => {
+    const realtimeVoice = (aiProvidersSchema().properties as Record<string, Record<string, unknown>>).realtimeVoice;
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(realtimeVoice);
+
+    expect(
+      validate({ transcription: 'streaming', turnDetection: 'semantic', bargeIn: 'supported' }),
+      why('RFC 0106 §A', 'a full transcription advertisement MUST validate'),
+    ).toBe(true);
+    expect(validate({}), why('RFC 0106 §A', 'an empty realtimeVoice object MUST validate')).toBe(true);
+    expect(
+      validate({ turnDetection: 'semantic' }),
+      why('RFC 0106 §A', 'turnDetection without transcription MUST be rejected (dependentRequired)'),
+    ).toBe(false);
+    expect(
+      validate({ bargeIn: 'supported' }),
+      why('RFC 0106 §A', 'bargeIn without transcription MUST be rejected (dependentRequired)'),
+    ).toBe(false);
+    expect(
+      validate({ transcription: 'streaming', turnDetection: 'aggressive' }),
+      why('RFC 0106 §A', 'an out-of-enum turnDetection MUST be rejected'),
+    ).toBe(false);
+    expect(
+      validate({ transcription: true }),
+      why('RFC 0106 §A', 'transcription MUST be the string const "streaming", not a boolean'),
+    ).toBe(false);
+  });
+
+  it('Ajv: the aiProviders subschema enforces realtimeVoice.synthesis ⇒ speechSynthesis', () => {
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(aiProvidersSchema());
+
+    expect(
+      validate({ realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
+      why('RFC 0106 §A', 'streaming synthesis without speechSynthesis: "supported" MUST be rejected'),
+    ).toBe(false);
+    expect(
+      validate({ speechSynthesis: 'supported', realtimeVoice: { transcription: 'streaming', synthesis: 'streaming' } }),
+      why('RFC 0106 §A', 'streaming synthesis WITH speechSynthesis: "supported" MUST validate'),
+    ).toBe(true);
+    expect(
+      validate({ realtimeVoice: { transcription: 'streaming' } }),
+      why('RFC 0106 §A', 'transcription-only (no synthesis) MUST validate without speechSynthesis'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/aiproviders-speechsynth-shape.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Speech-synthesis capability advertisement shape (RFC 0105 §B) — server-free.
+ *
+ * Always-on schema-shape probe for the RFC 0105 TTS adapter. Verifies that:
+ *   - `capabilities.aiProviders.speechSynthesis` is declared as the STRING
+ *     const `"supported"` (a sibling of `byok` / `input` in the `aiProviders`
+ *     block) — NOT an object. The const is what rejects an object-shaped
+ *     advertisement.
+ *   - `speechSynthesis` is NOT in `aiProviders.required`: absence is the
+ *     default (a host WITHOUT TTS is a valid discovery doc).
+ *   - via Ajv2020, a capabilities doc advertising
+ *     `aiProviders: { supported: ['minimax'], speechSynthesis: 'supported' }`
+ *     validates, while the object form
+ *     `aiProviders: { speechSynthesis: { supported: true } }` FAILS (the const
+ *     rejects the object).
+ *
+ * Behavioral assertions (the live `ctx.callSpeechSynthesizer` round-trip; the
+ * unadvertised-host reject) are gated on
+ * `aiProviders.speechSynthesis === 'supported'` and live in
+ * `speech-synthesis-roundtrip.test.ts` / `speech-synthesis-unadvertised.test.ts`.
+ * This scenario asserts the wire contract, not host behavior.
+ *
+ * Spec references:
+ *   - https://github.com/openwop/openwop/blob/main/spec/v1/host-capabilities.md (§host.aiProviders)
+ *   - https://github.com/openwop/openwop/blob/main/RFCS/0105-speech-synthesis-adapter.md (§B)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+/** Server-free assertion-message helper. */
+const why = (specRef: string, requirement: string): string => `${specRef} — ${requirement}`;
+
+function loadSchema(name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(SCHEMAS_DIR, name), 'utf8')) as Record<string, unknown>;
+}
+
+describe('aiproviders-speechsynth-shape: capability advertisement (RFC 0105 §B, server-free)', () => {
+  it('aiProviders.speechSynthesis is declared as the string const "supported"', () => {
+    const caps = loadSchema('capabilities.schema.json');
+    const aiProviders = (caps.properties as Record<string, { properties?: Record<string, unknown> }>)
+      .aiProviders;
+    const speechSynthesis = aiProviders?.properties?.speechSynthesis as
+      | { const?: unknown }
+      | undefined;
+    expect(
+      speechSynthesis,
+      why('host-capabilities.md §host.aiProviders', 'aiProviders.speechSynthesis MUST be declared'),
+    ).toBeDefined();
+    expect(
+      speechSynthesis?.const,
+      why('RFC 0105 §B', 'aiProviders.speechSynthesis MUST be the string const "supported" (not an object)'),
+    ).toBe('supported');
+  });
+
+  it('speechSynthesis is NOT in aiProviders.required — absence (no TTS) is a valid default', () => {
+    const caps = loadSchema('capabilities.schema.json');
+    const aiProviders = (caps.properties as Record<string, { required?: unknown }>).aiProviders;
+    const required = Array.isArray(aiProviders?.required) ? (aiProviders!.required as string[]) : [];
+    expect(
+      required.includes('speechSynthesis'),
+      why('RFC 0105 §B', 'aiProviders.speechSynthesis MUST be optional (a host without TTS is valid)'),
+    ).toBe(false);
+  });
+
+  it('Ajv accepts the string const form and rejects the object form', () => {
+    // Compile ONLY the speechSynthesis subschema (`{ const: "supported" }`) — the
+    // full capabilities.schema.json carries cross-file $refs that don't resolve
+    // standalone; the const flag has none, so it validates in isolation.
+    const caps = loadSchema('capabilities.schema.json');
+    const aiProviders = (caps.properties as Record<string, { properties?: Record<string, unknown> }>).aiProviders;
+    const speechSynthesisSchema = aiProviders?.properties?.speechSynthesis as Record<string, unknown>;
+
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(speechSynthesisSchema);
+
+    expect(
+      validate('supported'),
+      why('RFC 0105 §B', 'aiProviders.speechSynthesis === "supported" MUST validate'),
+    ).toBe(true);
+
+    expect(
+      validate({ supported: true }),
+      why('RFC 0105 §B', 'the object form { supported: true } MUST be rejected by the const'),
+    ).toBe(false);
+  });
+});