@independo/inderun-contracts 0.4.0 → 0.5.0-rc.2

package/dist/generated/schemas.d.ts

@@ -2,14 +2,72 @@ export declare const taskRequestSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/task-request.schema.json";
     readonly title: "TaskRequest";
-    readonly description: "The request payload for a Mode 1 (request/response) text-to-text execution. At least one of `prompt` (single-turn) or `messages` (multi-turn) must be present — both may be present together, though callers should typically supply just one; `constraints`/`preferences` steer routing but never select a provider directly.";
+    readonly description: "The request payload for a run() or stream() execution. The common envelope (schemaVersion, requestId, task, modelProfile, constraints, preferences, telemetry, authContextRef) is task-agnostic; each task kind owns its payload (ADR 016). text_to_text: at least one of `prompt` (single-turn) or `messages` (multi-turn) must be present — both may be present together, though callers should typically supply just one — and `speech`/`delivery` are forbidden. text_to_speech: `speech` and `delivery` are required and `prompt`, `messages` and `generation` are forbidden. `constraints`/`preferences` steer routing but never select a provider directly.";
     readonly type: "object";
     readonly additionalProperties: true;
     readonly required: readonly ["schemaVersion", "task"];
-    readonly anyOf: readonly [{
-        readonly required: readonly ["prompt"];
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly task: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "text_to_text";
+                        };
+                    };
+                };
+            };
+        };
+        readonly then: {
+            readonly anyOf: readonly [{
+                readonly required: readonly ["prompt"];
+            }, {
+                readonly required: readonly ["messages"];
+            }];
+            readonly not: {
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["speech"];
+                }, {
+                    readonly required: readonly ["delivery"];
+                }];
+            };
+        };
     }, {
-        readonly required: readonly ["messages"];
+        readonly if: {
+            readonly properties: {
+                readonly task: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly kind: {
+                            readonly const: "text_to_speech";
+                        };
+                    };
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["speech", "delivery"];
+            readonly not: {
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["prompt"];
+                }, {
+                    readonly required: readonly ["messages"];
+                }, {
+                    readonly required: readonly ["generation"];
+                }];
+            };
+            readonly properties: {
+                readonly delivery: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly mode: {
+                            readonly enum: readonly ["playback", "artifact"];
+                        };
+                    };
+                };
+            };
+        };
     }];
     readonly properties: {
         readonly schemaVersion: {
@@ -22,14 +80,15 @@ export declare const taskRequestSchema: {
             readonly minLength: 1;
         };
         readonly task: {
-            readonly description: "A descriptor specifying the type of work to be performed. For text-to-text, the kind must be 'text_to_text'.";
+            readonly description: "A descriptor specifying the type of work to be performed. The kind selects which payload the request must carry.";
             readonly type: "object";
             readonly additionalProperties: true;
             readonly required: readonly ["kind"];
             readonly properties: {
                 readonly kind: {
-                    readonly description: "The standard task category. Currently supports 'text_to_text' for prompt-based interactions.";
-                    readonly const: "text_to_text";
+                    readonly title: "TaskKind";
+                    readonly description: "The operation: 'text_to_text' (prompt-based text generation) or 'text_to_speech' (speech synthesis from text). A consumer built against an older revision rejects a kind it does not know through validation.";
+                    readonly enum: readonly ["text_to_text", "text_to_speech"];
                 };
             };
         };
@@ -60,6 +119,100 @@ export declare const taskRequestSchema: {
                 };
             };
         };
+        readonly speech: {
+            readonly title: "SpeechInput";
+            readonly description: "The text_to_speech payload. Required for text_to_speech and forbidden for every other kind.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["text", "locale"];
+            readonly properties: {
+                readonly text: {
+                    readonly description: "Plain text to speak. Markup such as SSML is out of scope.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly locale: {
+                    readonly description: "BCP 47 tag of the language to speak, e.g. 'de-AT'.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly localeMatch: {
+                    readonly title: "LocaleMatch";
+                    readonly description: "'language' (default): the primary language subtag is a hard requirement and the region is a preference. 'exact': the full tag is a hard requirement.";
+                    readonly enum: readonly ["exact", "language"];
+                };
+                readonly voice: {
+                    readonly title: "SpeechVoice";
+                    readonly description: "Provider-neutral voice traits. A 'preferred' voice (default) shapes which voice speaks and is never a reason to fail; a 'required' one takes part in routing and is never relaxed silently. Carries no provider voice identifier.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly if: {
+                        readonly properties: {
+                            readonly requirement: {
+                                readonly const: "required";
+                            };
+                        };
+                        readonly required: readonly ["requirement"];
+                    };
+                    readonly then: {
+                        readonly required: readonly ["gender"];
+                    };
+                    readonly properties: {
+                        readonly gender: {
+                            readonly $ref: "provider-dynamic-capabilities.schema.json#/$defs/voiceGender";
+                        };
+                        readonly requirement: {
+                            readonly title: "RequirementLevel";
+                            readonly description: "'preferred' (default) or 'required'. A required voice must name at least one trait.";
+                            readonly enum: readonly ["required", "preferred"];
+                        };
+                    };
+                };
+            };
+        };
+        readonly delivery: {
+            readonly title: "OutputDeliveryRequest";
+            readonly description: "How the result of a non-text task must reach the application (ADR 016). Required for non-text tasks and forbidden for text_to_text, whose output is implicitly inline. A provider never substitutes playback for an artifact or the reverse.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["mode"];
+            readonly if: {
+                readonly properties: {
+                    readonly mode: {
+                        readonly const: "artifact";
+                    };
+                };
+            };
+            readonly else: {
+                readonly not: {
+                    readonly anyOf: readonly [{
+                        readonly required: readonly ["mediaTypes"];
+                    }, {
+                        readonly required: readonly ["destinationRef"];
+                    }];
+                };
+            };
+            readonly properties: {
+                readonly mode: {
+                    readonly $ref: "provider-descriptor.schema.json#/$defs/outputDelivery";
+                };
+                readonly mediaTypes: {
+                    readonly description: "Only valid with 'artifact' delivery: the acceptable media types, always a hard requirement. Absent means the provider chooses and the artifact reports what it produced.";
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly destinationRef: {
+                    readonly description: "Only valid with 'artifact' delivery: an opaque reference to an application destination the engine writes the finished artifact to, resolved by the host's artifact-destination service (ADR 017) -- never a raw path or URL, like authContextRef for credentials. The result's artifact is then application-owned and the engine keeps no copy. A host without the service refuses the request before routing.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
         readonly modelProfile: {
             readonly description: "Name of the model profile to route within, as configured on the engine. Absent or 'auto' means every registered target, ranked by constraints and preferences alone. A profile is an application-defined, ordered allow-list of targets (provider instances bound to one model each); raw model or provider identifiers are never accepted here. An unknown profile name fails request validation.";
             readonly type: "string";
@@ -114,7 +267,7 @@ export declare const taskRequestSchema: {
                     readonly enum: readonly ["forbidden", "allowed", "required"];
                 };
                 readonly timeoutMs: {
-                    readonly description: "Optional routing timeout budget in milliseconds.";
+                    readonly description: "Optional timeout budget in milliseconds, passed to the planner and to providers. It bounds the time until the run commits to a provider -- its first content, its first possible audible effect, or its artifact handoff -- not the duration of audio it plays. The engines add no timers of their own.";
                     readonly type: "integer";
                     readonly minimum: 1;
                 };
@@ -164,7 +317,7 @@ export declare const taskResultSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/task-result.schema.json";
     readonly title: "TaskResult";
-    readonly description: "The response payload for a completed text-to-text execution. A full execution failure (validation, routing, or every attempted provider failing) is surfaced by run() throwing an IndeRunError instead of returning a TaskResult; finishReason and telemetry.errorClass are reserved for a provider reporting a non-fatal, degraded outcome on an otherwise-successful result (finishReason 'error' is produced by the Android ML Kit GenAI provider; telemetry.errorClass is not currently set by any provider in this codebase).";
+    readonly description: "The response payload for a completed run() execution, for every task kind; output.type tells the content representation apart (text, managed playback, retrievable artifact). A full execution failure (validation, routing, or every attempted provider failing) is surfaced by run() throwing an IndeRunError instead of returning a TaskResult; finishReason and telemetry.errorClass are reserved for a provider reporting a non-fatal, degraded outcome on an otherwise-successful result (finishReason 'error' is produced by the Android ML Kit GenAI provider; telemetry.errorClass is not currently set by any provider in this codebase).";
     readonly type: "object";
     readonly additionalProperties: true;
     readonly required: readonly ["schemaVersion", "runId", "output", "finishReason", "telemetry"];
@@ -179,20 +332,8 @@ export declare const taskResultSchema: {
             readonly minLength: 1;
         };
         readonly output: {
-            readonly description: "The normalized content returned from the selected provider.";
-            readonly type: "object";
-            readonly additionalProperties: true;
-            readonly required: readonly ["type", "text"];
-            readonly properties: {
-                readonly type: {
-                    readonly description: "Output payload category (e.g., 'text' for Mode 1 text-to-text).";
-                    readonly const: "text";
-                };
-                readonly text: {
-                    readonly description: "The actual text generated by the execution.";
-                    readonly type: "string";
-                };
-            };
+            readonly description: "The normalized output of the selected provider. See task-output.schema.json.";
+            readonly $ref: "task-output.schema.json";
         };
         readonly finishReason: {
             readonly description: "How generation ended: 'stop' (natural end), 'length' (hit maxOutputTokens), or 'cancelled'. 'error' is reserved for a provider reporting a non-fatal issue on an otherwise-returned result — the Android ML Kit GenAI provider produces it when Gemini Nano reports a finish reason that is neither a natural stop nor the token limit. A full execution failure is instead surfaced by run() throwing an IndeRunError.";
@@ -383,6 +524,7 @@ export declare const telemetryEventSchema: {
     readonly required: readonly ["type", "runId", "timestamp", "payload"];
     readonly properties: {
         readonly type: {
+            readonly title: "TelemetryEventType";
             readonly description: "Telemetry event kind emitted by the orchestrator or provider integration.";
             readonly enum: readonly ["route_decided", "attempt_succeeded", "attempt_failed", "stream_attempt_started", "stream_attempt_succeeded", "stream_attempt_failed", "stream_completed", "stream_failed", "stream_cancelled"];
         };
@@ -413,15 +555,79 @@ export declare const routePlannerInputSchema: {
     readonly required: readonly ["task", "constraints", "preferences", "providers"];
     readonly properties: {
         readonly task: {
-            readonly description: "Minimal task descriptor for provider task matching.";
+            readonly description: "Task descriptor for provider task matching: the kind plus the requirements routing can check against declared capabilities. Absent requirement fields are never checked, so a text request carries the kind alone.";
             readonly type: "object";
             readonly additionalProperties: true;
             readonly required: readonly ["kind"];
             readonly properties: {
                 readonly kind: {
+                    readonly description: "The task kind, matched against the providers' task capabilities.";
                     readonly type: "string";
                     readonly minLength: 1;
                 };
+                readonly inputs: {
+                    readonly description: "Input media kinds the request carries. Every one must be accepted by the provider's task capability. The SDKs send ['text'] for text_to_text.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "provider-descriptor.schema.json#/$defs/inputKind";
+                    };
+                };
+                readonly delivery: {
+                    readonly title: "DeliveryRequirement";
+                    readonly description: "The output delivery the request requires. Absent for text, whose delivery is implicitly inline.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["mode"];
+                    readonly properties: {
+                        readonly mode: {
+                            readonly $ref: "provider-descriptor.schema.json#/$defs/outputDelivery";
+                        };
+                        readonly mediaTypes: {
+                            readonly description: "Acceptable media types; the provider must declare at least one for the requested delivery. Absent means any.";
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                };
+                readonly locale: {
+                    readonly title: "LocaleRequirement";
+                    readonly description: "The locale the request requires. Under 'language' matching the region is a preference: a provider known to offer the exact tag ranks ahead of an otherwise equal one. A provider that cannot enumerate its locales is not rejected on this basis; it must fail before committing instead.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["tag", "match"];
+                    readonly properties: {
+                        readonly tag: {
+                            readonly description: "BCP 47 tag.";
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly match: {
+                            readonly title: "LocaleMatch";
+                            readonly description: "'exact' requires the full tag; 'language' requires only the primary language subtag and treats the region as a preference.";
+                            readonly enum: readonly ["exact", "language"];
+                        };
+                    };
+                };
+                readonly voice: {
+                    readonly title: "VoiceRequirement";
+                    readonly description: "Voice traits the request asks for. Only a 'required' voice can reject a provider; a 'preferred' one shapes which listed voice the plan binds a candidate to, always within the request's privacy policy.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["requirement"];
+                    readonly properties: {
+                        readonly gender: {
+                            readonly $ref: "provider-dynamic-capabilities.schema.json#/$defs/voiceGender";
+                        };
+                        readonly requirement: {
+                            readonly title: "RequirementLevel";
+                            readonly description: "'required' takes part in routing; 'preferred' does not.";
+                            readonly enum: readonly ["required", "preferred"];
+                        };
+                    };
+                };
             };
         };
         readonly interactionMode: {
@@ -481,7 +687,7 @@ export declare const routePlannerInputSchema: {
             };
         };
         readonly providers: {
-            readonly description: "Static descriptors plus dynamic capability snapshots for planning.";
+            readonly description: "Static descriptors plus dynamic capability checks for planning. Both shapes are the provider schemas themselves, shared by $ref, so the planner reads exactly what checkCapabilities() reports.";
             readonly type: "array";
             readonly items: {
                 readonly type: "object";
@@ -489,88 +695,12 @@ export declare const routePlannerInputSchema: {
                 readonly required: readonly ["descriptor", "capabilities"];
                 readonly properties: {
                     readonly descriptor: {
-                        readonly type: "object";
-                        readonly additionalProperties: true;
-                        readonly required: readonly ["id", "type", "supports", "tasks"];
-                        readonly properties: {
-                            readonly id: {
-                                readonly type: "string";
-                                readonly minLength: 1;
-                            };
-                            readonly type: {
-                                readonly enum: readonly ["local", "edge", "cloud"];
-                            };
-                            readonly supports: {
-                                readonly type: "object";
-                                readonly additionalProperties: true;
-                                readonly required: readonly ["run"];
-                                readonly properties: {
-                                    readonly run: {
-                                        readonly type: "boolean";
-                                    };
-                                    readonly streaming: {
-                                        readonly description: "Whether the provider statically declares Mode-2 streaming. Absent is treated as false: a descriptor that predates this field cannot be assumed to stream.";
-                                        readonly type: "boolean";
-                                    };
-                                };
-                            };
-                            readonly cancel: {
-                                readonly description: "Cancellation guarantee the provider offers. Carried for route explanations and telemetry; the planner does not filter on it.";
-                                readonly enum: readonly ["hard", "soft", "none"];
-                            };
-                            readonly tasks: {
-                                readonly type: "array";
-                                readonly items: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                };
-                            };
-                            readonly privacy: {
-                                readonly description: "Descriptor privacy metadata used to enforce local/cloud routing rules.";
-                                readonly type: "object";
-                                readonly additionalProperties: true;
-                                readonly required: readonly ["dataLeavesDevice"];
-                                readonly properties: {
-                                    readonly dataLeavesDevice: {
-                                        readonly type: "boolean";
-                                    };
-                                    readonly regions: {
-                                        readonly type: "array";
-                                        readonly items: {
-                                            readonly type: "string";
-                                            readonly minLength: 1;
-                                        };
-                                    };
-                                };
-                            };
-                        };
+                        readonly description: "The provider's static capability declaration.";
+                        readonly $ref: "provider-descriptor.schema.json";
                     };
                     readonly capabilities: {
-                        readonly type: "object";
-                        readonly additionalProperties: true;
-                        readonly required: readonly ["available"];
-                        readonly properties: {
-                            readonly available: {
-                                readonly type: "boolean";
-                            };
-                            readonly reason: {
-                                readonly type: "string";
-                                readonly minLength: 1;
-                            };
-                            readonly streamingAvailable: {
-                                readonly description: "Whether the provider can stream right now in this host environment. Absent inherits the static descriptor.supports.streaming value.";
-                                readonly type: "boolean";
-                            };
-                            readonly streamingUnavailableReason: {
-                                readonly description: "Human-readable explanation used when streamingAvailable is false. Absent lets the planner synthesize a default message.";
-                                readonly type: "string";
-                                readonly minLength: 1;
-                            };
-                            readonly cancellationAvailable: {
-                                readonly description: "Whether cancellation is honored right now in this host environment. Absent inherits the static descriptor.cancel value (any value other than 'none' means available).";
-                                readonly type: "boolean";
-                            };
-                        };
+                        readonly description: "The provider's live capability check, already folded by the engine (for example, streamingAvailable is false when the provider declares streaming but does not implement it).";
+                        readonly $ref: "provider-dynamic-capabilities.schema.json";
                     };
                 };
             };
@@ -615,6 +745,10 @@ export declare const routePlanSchema: {
                         readonly type: "integer";
                         readonly minimum: 0;
                     };
+                    readonly voice: {
+                        readonly description: "The voice this candidate must use if it is attempted, chosen by the planner from the provider's dynamic voice inventory. It is the best voice that satisfies the request's locale, required voice traits and privacy — under local-required privacy always one that keeps data on the device — ranked by preferred gender, then exact locale region, then on-device before network. The adapter must use a voice with exactly these traits. Absent when the request names no locale or voice, or the provider does not list its voices; the adapter then chooses itself under the same rules.";
+                        readonly $ref: "provider-dynamic-capabilities.schema.json#/$defs/voice";
+                    };
                 };
             };
         };
@@ -638,8 +772,8 @@ export declare const routePlanSchema: {
                             readonly required: readonly ["code", "message"];
                             readonly properties: {
                                 readonly code: {
-                                    readonly description: "Normalized rejection reason. 'streaming_not_supported' means the descriptor does not statically declare Mode-2 streaming; 'streaming_unavailable' means it declares streaming but the dynamic capability snapshot reports it cannot stream in the current host environment. 'not_in_model_profile' means the request named a model profile that does not list this provider.";
-                                    readonly enum: readonly ["task_not_supported", "run_not_supported", "streaming_not_supported", "streaming_unavailable", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable", "not_in_model_profile"];
+                                    readonly description: "Normalized rejection reason. 'streaming_not_supported' means the descriptor does not statically declare Mode-2 streaming; 'streaming_unavailable' means it declares streaming but the dynamic capability snapshot reports it cannot stream in the current host environment. 'not_in_model_profile' means the request named a model profile that does not list this provider. 'input_not_supported', 'output_delivery_not_supported', 'output_format_not_supported', 'locale_not_supported' and 'voice_not_available' mean the provider's task capability lacks an input kind, output delivery, media type, locale or voice the request requires.";
+                                    readonly enum: readonly ["task_not_supported", "run_not_supported", "streaming_not_supported", "streaming_unavailable", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable", "not_in_model_profile", "input_not_supported", "output_delivery_not_supported", "output_format_not_supported", "locale_not_supported", "voice_not_available"];
                                 };
                                 readonly message: {
                                     readonly type: "string";
@@ -1053,7 +1187,12 @@ export declare const streamEventSchema: {
                 readonly oneOf: readonly [{
                     readonly type: "object";
                     readonly additionalProperties: true;
-                    readonly required: readonly ["schemaVersion", "runId", "outcome", "finalText"];
+                    readonly required: readonly ["schemaVersion", "runId", "outcome"];
+                    readonly anyOf: readonly [{
+                        readonly required: readonly ["finalText"];
+                    }, {
+                        readonly required: readonly ["output"];
+                    }];
                     readonly properties: {
                         readonly schemaVersion: {
                             readonly const: "1.0";
@@ -1068,6 +1207,9 @@ export declare const streamEventSchema: {
                         readonly finalText: {
                             readonly type: "string";
                         };
+                        readonly output: {
+                            readonly $ref: "task-output.schema.json";
+                        };
                         readonly finishReason: {
                             readonly enum: readonly ["stop", "length", "cancelled", "error"];
                         };
@@ -1124,6 +1266,9 @@ export declare const streamEventSchema: {
                         readonly outcome: {
                             readonly const: "error";
                         };
+                        readonly partialText: {
+                            readonly type: "string";
+                        };
                         readonly error: {
                             readonly type: "object";
                             readonly additionalProperties: true;
@@ -1168,7 +1313,7 @@ export declare const streamEventSchema: {
                 }, {
                     readonly type: "object";
                     readonly additionalProperties: true;
-                    readonly required: readonly ["schemaVersion", "runId", "outcome", "partialText"];
+                    readonly required: readonly ["schemaVersion", "runId", "outcome"];
                     readonly properties: {
                         readonly schemaVersion: {
                             readonly const: "1.0";
@@ -1183,6 +1328,9 @@ export declare const streamEventSchema: {
                         readonly partialText: {
                             readonly type: "string";
                         };
+                        readonly output: {
+                            readonly $ref: "task-output.schema.json";
+                        };
                         readonly reason: {
                             readonly type: "string";
                         };
@@ -1237,11 +1385,16 @@ export declare const streamTerminalOutcomeSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/stream-terminal-outcome.schema.json";
     readonly title: "StreamTerminalOutcome";
-    readonly description: "How a Mode 2 stream run ended. Completion, error, and cancellation are mutually exclusive terminal outcomes, enforced here as a closed set of three oneOf branches discriminated by 'outcome' (unlike StreamEvent.type, this set is not open-ended: the three-way terminal outcome is a fixed architectural guarantee, not something new outcome kinds get added to). Exactly one StreamTerminalOutcome is produced per run, and no further StreamEvent is delivered after it (see docs/architecture/architecture.md, 'Cancellation And Fallback'). This shape is also embedded by value as the payload of the terminal StreamEvent (stream-event.schema.json) so it can additionally be exposed standalone, e.g. as a completion future/promise a stream handle resolves independently of consuming the full event sequence; the two copies must stay structurally identical. Note on additionalProperties: per this repo's forward-compatible convention every branch permits unknown extra fields, so mutual exclusivity is enforced via the required 'outcome' discriminator plus each branch's own required peer field (finalText/error/partialText) being present, not by forbidding a payload from also carrying an unrelated stray field from another branch's vocabulary.";
+    readonly description: "How a Mode 2 stream run ended. Completion, error, and cancellation are mutually exclusive terminal outcomes, enforced here as a closed set of three oneOf branches discriminated by 'outcome' (unlike StreamEvent.type, this set is not open-ended: the three-way terminal outcome is a fixed architectural guarantee, not something new outcome kinds get added to; the payload of each branch may grow additively). Exactly one StreamTerminalOutcome is produced per run, and no further StreamEvent is delivered after it (see docs/architecture/architecture.md, 'Cancellation And Fallback'). This shape is also embedded by value as the payload of the terminal StreamEvent (stream-event.schema.json) so it can additionally be exposed standalone, e.g. as a completion future/promise a stream handle resolves independently of consuming the full event sequence; the two copies must stay structurally identical. Note on additionalProperties: per this repo's forward-compatible convention every branch permits unknown extra fields, so mutual exclusivity is enforced via the required 'outcome' discriminator plus each branch's own required peer field being present (finalText or output / error), and for 'cancelled' by the discriminator alone, not by forbidding a payload from also carrying an unrelated stray field from another branch's vocabulary.";
     readonly oneOf: readonly [{
         readonly type: "object";
         readonly additionalProperties: true;
-        readonly required: readonly ["schemaVersion", "runId", "outcome", "finalText"];
+        readonly required: readonly ["schemaVersion", "runId", "outcome"];
+        readonly anyOf: readonly [{
+            readonly required: readonly ["finalText"];
+        }, {
+            readonly required: readonly ["output"];
+        }];
         readonly properties: {
             readonly schemaVersion: {
                 readonly description: "Contract schema version used to interpret this outcome payload.";
@@ -1257,9 +1410,13 @@ export declare const streamTerminalOutcomeSchema: {
                 readonly const: "completed";
             };
             readonly finalText: {
-                readonly description: "The full, cumulative text produced by the run. Equivalent in role to TaskResult.output.text for Mode 1.";
+                readonly description: "The full, cumulative text produced by a text run. Equivalent in role to TaskResult.output.text for Mode 1. A text run sets it; a non-text run carries output instead.";
                 readonly type: "string";
             };
+            readonly output: {
+                readonly description: "The normalized output of the run, the same shape run() returns in TaskResult.output. Set for every non-text run; a text run may set it alongside finalText. See task-output.schema.json.";
+                readonly $ref: "task-output.schema.json";
+            };
             readonly finishReason: {
                 readonly description: "How generation ended, mirroring TaskResult.finishReason for Mode 1: 'stop' (natural end), 'length' (hit maxOutputTokens), 'error' (provider reported a non-fatal issue on an otherwise completed run). 'cancelled' is included so this enum stays identical to TaskResult.finishReason, but it is unreachable here: cancellation is its own terminal outcome branch. Optional: providers that do not report a finish reason omit it.";
                 readonly enum: readonly ["stop", "length", "cancelled", "error"];
@@ -1371,6 +1528,10 @@ export declare const streamTerminalOutcomeSchema: {
                     };
                 };
             };
+            readonly partialText: {
+                readonly description: "Whatever cumulative text a text run had already delivered before it failed after committing to its provider. Absent when nothing was delivered.";
+                readonly type: "string";
+            };
             readonly provenance: {
                 readonly description: "Normalized execution provenance: which target ran, its declared locality, the configured and reported model, and how fallback and routing played out. See execution-provenance.schema.json.";
                 readonly $ref: "execution-provenance.schema.json";
@@ -1379,7 +1540,7 @@ export declare const streamTerminalOutcomeSchema: {
     }, {
         readonly type: "object";
         readonly additionalProperties: true;
-        readonly required: readonly ["schemaVersion", "runId", "outcome", "partialText"];
+        readonly required: readonly ["schemaVersion", "runId", "outcome"];
         readonly properties: {
             readonly schemaVersion: {
                 readonly description: "Contract schema version used to interpret this outcome payload.";
@@ -1395,9 +1556,13 @@ export declare const streamTerminalOutcomeSchema: {
                 readonly const: "cancelled";
             };
             readonly partialText: {
-                readonly description: "Whatever cumulative text had already been delivered via content_delta/content_snapshot StreamEvents before the cancellation point. May be empty if cancellation occurred before any content was produced.";
+                readonly description: "Whatever cumulative text a text run had already delivered via content_delta/content_snapshot StreamEvents before the cancellation point. Always set for a text run, and empty if cancellation occurred before any content was produced. A non-text run never sets it.";
                 readonly type: "string";
             };
+            readonly output: {
+                readonly description: "What a cancelled non-text run had already produced: a playback run that committed (audio may have been heard) carries a playback output, and an artifact run cancelled while the engine was writing its artifact to an application destination carries that application-owned artifact, whose bytes the write left at the destination. Absent when nothing was produced, e.g. an artifact run cancelled before its artifact was handed over, whose partial media the engine discards. See task-output.schema.json.";
+                readonly $ref: "task-output.schema.json";
+            };
             readonly reason: {
                 readonly description: "Optional human-readable reason the run was cancelled (e.g. caller-initiated abort). Not a machine-taxonomy field; use errorClass on the 'error' outcome branch for failure classification.";
                 readonly type: "string";
@@ -1409,6 +1574,555 @@ export declare const streamTerminalOutcomeSchema: {
         };
     }];
 };
+export declare const providerCapabilitySnapshotSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/provider-capability-snapshot.schema.json";
+    readonly title: "ProviderCapabilitySnapshot";
+    readonly description: "One registered provider's identity, static declaration and live capability check, as returned by checkCapabilities(). A read-only snapshot: producing it executes no task and has no side effects.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["providerId", "descriptor", "capabilities"];
+    readonly properties: {
+        readonly providerId: {
+            readonly description: "Identifier of the provider; equal to descriptor.id.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly descriptor: {
+            readonly description: "The provider's static capability declaration.";
+            readonly $ref: "provider-descriptor.schema.json";
+        };
+        readonly capabilities: {
+            readonly description: "The provider's live capability check at the time of the call.";
+            readonly $ref: "provider-dynamic-capabilities.schema.json";
+        };
+    };
+};
+export declare const providerDescriptorSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/provider-descriptor.schema.json";
+    readonly title: "ProviderDescriptor";
+    readonly description: "A provider's static capability declaration: identity, placement, transport, supported interaction modes and tasks, cancellation guarantee, resource limits and privacy posture. It does not change while the provider is registered. The route planner, checkCapabilities() and execution provenance all read this one shape.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["id", "type", "transport", "supports", "cancel", "tasks"];
+    readonly properties: {
+        readonly id: {
+            readonly description: "Unique identifier of the provider instance (a target), e.g. 'apple_foundation_models' or 'openai_compatible_cloud:gpt-5-mini'. Model profiles list targets by this id.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly type: {
+            readonly title: "ProviderType";
+            readonly description: "Execution placement: 'local' (on the device), 'edge', or 'cloud'.";
+            readonly enum: readonly ["local", "edge", "cloud"];
+        };
+        readonly model: {
+            readonly description: "The model this provider instance is bound to, when it can name one. Cloud providers report the model id they send; platform-managed models report an opaque platform alias rather than a guessed weight name. Absent means the provider cannot name its model.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly transport: {
+            readonly title: "ProviderTransport";
+            readonly description: "How the engine reaches the provider: in-process runtime, operating-system service, buffered HTTP, server-sent events, or a realtime connection.";
+            readonly enum: readonly ["in_process", "system_service", "http", "sse", "realtime"];
+        };
+        readonly streamingStyle: {
+            readonly title: "StreamingStyle";
+            readonly description: "How a streaming provider delivers incremental output: individual tokens, larger chunks, or whole snapshots. Absent for providers that do not stream.";
+            readonly enum: readonly ["tokens", "chunks", "snapshots"];
+        };
+        readonly supports: {
+            readonly title: "ProviderSupports";
+            readonly description: "Interaction modes and features the provider statically declares.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["run", "streaming", "realtime", "tools", "reasoningEvents", "structuredOutput", "multimodal"];
+            readonly properties: {
+                readonly run: {
+                    readonly description: "Whether the provider supports Mode 1 run (request/response).";
+                    readonly type: "boolean";
+                };
+                readonly streaming: {
+                    readonly description: "Whether the provider supports Mode 2 stream. A provider that declares it must also implement the streaming adapter; the engines report it as unavailable otherwise.";
+                    readonly type: "boolean";
+                };
+                readonly realtime: {
+                    readonly description: "Whether the provider supports Mode 3 realtime sessions. Reserved; no engine implements Mode 3 yet.";
+                    readonly type: "boolean";
+                };
+                readonly tools: {
+                    readonly description: "Whether the provider supports tool calling.";
+                    readonly type: "boolean";
+                };
+                readonly reasoningEvents: {
+                    readonly description: "Whether the provider emits reasoning events alongside content.";
+                    readonly type: "boolean";
+                };
+                readonly structuredOutput: {
+                    readonly description: "Whether the provider supports structured output constrained by a JSON schema.";
+                    readonly type: "boolean";
+                };
+                readonly multimodal: {
+                    readonly description: "Whether the provider accepts non-text inputs such as images or audio.";
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly cancel: {
+            readonly title: "CancelSemantics";
+            readonly description: "Cancellation guarantee: 'hard' stops processing including remote work, 'soft' stops reading locally while remote work may continue, 'none' means cancellation is unsupported. Independently of this value, the engine delivers no event after a cancel.";
+            readonly enum: readonly ["hard", "soft", "none"];
+        };
+        readonly tasks: {
+            readonly description: "Task kinds the provider supports, e.g. 'text_to_text'. When taskCapabilities is present it must describe the same kinds and is what routing reads; without it, routing infers capabilities for 'text_to_text' alone (see taskCapabilities).";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly limits: {
+            readonly title: "ProviderLimits";
+            readonly description: "Optional input and output resource limits.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly maxInputTokens: {
+                    readonly description: "Largest accepted input, in tokens.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly maxOutputTokens: {
+                    readonly description: "Largest output the provider produces, in tokens.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly maxImageBytes: {
+                    readonly description: "Largest accepted image, in bytes.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly maxAudioSeconds: {
+                    readonly description: "Longest accepted or produced audio, in seconds.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+            };
+        };
+        readonly privacy: {
+            readonly title: "ProviderPrivacy";
+            readonly description: "Data-egress posture, used to enforce local and cloud routing rules. Absent means a local or edge provider is treated as keeping data on the device and a cloud provider as sending it off.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["dataLeavesDevice"];
+            readonly properties: {
+                readonly dataLeavesDevice: {
+                    readonly description: "Whether request content leaves the device.";
+                    readonly type: "boolean";
+                };
+                readonly regions: {
+                    readonly description: "Geographic regions where a cloud provider processes data.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly taskCapabilities: {
+            readonly description: "What the provider can do for each task: accepted inputs, interaction modes, output deliveries and formats, cancellation, locales and privacy. When present it is authoritative for routing and must list every task the provider serves. When absent (a legacy descriptor), routing infers exactly one entry — 'text_to_text' with text input, inline output, run/stream from supports and cancel from cancel — if tasks contains 'text_to_text', and nothing for any other task: a legacy descriptor is never treated as capable of a non-text task.";
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/$defs/taskCapability";
+            };
+        };
+    };
+    readonly $defs: {
+        readonly taskCapability: {
+            readonly title: "ProviderTaskCapability";
+            readonly description: "The provider's static capabilities for one task kind.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["kind", "inputs", "interaction", "cancel", "outputs"];
+            readonly properties: {
+                readonly kind: {
+                    readonly description: "The task kind this entry describes, e.g. 'text_to_speech'.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly inputs: {
+                    readonly description: "Input media kinds the provider accepts for this task.";
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly $ref: "#/$defs/inputKind";
+                    };
+                };
+                readonly interaction: {
+                    readonly title: "ProviderTaskInteraction";
+                    readonly description: "Interaction modes the provider supports for this task.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["run", "stream"];
+                    readonly properties: {
+                        readonly run: {
+                            readonly description: "Whether the provider supports Mode 1 run for this task.";
+                            readonly type: "boolean";
+                        };
+                        readonly stream: {
+                            readonly description: "Whether the provider supports Mode 2 stream for this task.";
+                            readonly type: "boolean";
+                        };
+                    };
+                };
+                readonly cancel: {
+                    readonly description: "Cancellation guarantee for this task. It may differ from the provider-level cancel, e.g. when stopping playback is immediate but a synthesis request cannot be aborted.";
+                    readonly $ref: "#/properties/cancel";
+                };
+                readonly outputs: {
+                    readonly description: "How results of this task can be delivered. A provider lists only what it really produces: a provider that can only play audio lists 'playback' and never 'artifact'.";
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly $ref: "#/$defs/taskOutput";
+                    };
+                };
+                readonly locales: {
+                    readonly description: "BCP 47 locales the provider can serve for this task, when it knows them statically. Absent means unknown; the dynamic check may report them instead.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly privacy: {
+                    readonly description: "Data-egress posture for this task when it differs from the provider-level privacy, e.g. a provider whose speech synthesis uses a network service. Absent inherits descriptor.privacy.";
+                    readonly $ref: "#/properties/privacy";
+                };
+            };
+        };
+        readonly taskOutput: {
+            readonly title: "ProviderTaskOutput";
+            readonly description: "One way the provider can deliver a task's result.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["delivery"];
+            readonly properties: {
+                readonly delivery: {
+                    readonly $ref: "#/$defs/outputDelivery";
+                };
+                readonly mediaTypes: {
+                    readonly description: "Media types the provider can produce with this delivery, e.g. 'audio/wav'. Absent means the provider does not declare them; a request that requires specific media types never routes to such an output.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly inputKind: {
+            readonly title: "TaskInputKind";
+            readonly description: "A kind of input medium a task consumes.";
+            readonly enum: readonly ["text", "image", "audio"];
+        };
+        readonly outputDelivery: {
+            readonly title: "OutputDelivery";
+            readonly description: "How a task's result reaches the application: 'inline' content in the result (text), 'playback' as a managed, audible effect on the device with no retrievable bytes, or 'artifact' as retrievable media.";
+            readonly enum: readonly ["inline", "playback", "artifact"];
+        };
+    };
+};
+export declare const providerDynamicCapabilitiesSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/provider-dynamic-capabilities.schema.json";
+    readonly title: "ProviderDynamicCapabilities";
+    readonly $comment: "streamingAvailable and cancellationAvailable are tri-state on purpose: true, false, or absent. Absent means 'inherit the static declaration' and is a distinct state from both booleans. They must never become nullable: null would be a fourth state no consumer handles, and bridges omit the key specifically to preserve 'absent'.";
+    readonly description: "A provider's live capability check, evaluated on the current host when routing or when checkCapabilities() is called. Unlike the descriptor it can change between calls.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["available"];
+    readonly properties: {
+        readonly available: {
+            readonly description: "Whether the provider is available and functional on this host right now.";
+            readonly type: "boolean";
+        };
+        readonly reason: {
+            readonly description: "Why the provider is unavailable, when available is false.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly streamingAvailable: {
+            readonly description: "Whether the provider can stream (Mode 2) on this host right now. Absent inherits the static descriptor.supports.streaming value; only set it when the host takes streaming away from a provider that otherwise declares it. Never null.";
+            readonly type: "boolean";
+        };
+        readonly streamingUnavailableReason: {
+            readonly description: "Why streaming is unavailable, when streamingAvailable is false. Absent lets the route planner synthesize a default message.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly cancellationAvailable: {
+            readonly description: "Whether cancellation is honored on this host right now. Absent inherits the static descriptor.cancel value: any value other than 'none' means available. Never null.";
+            readonly type: "boolean";
+        };
+        readonly taskCapabilities: {
+            readonly description: "Per-task overrides of the provider-level check, for tasks whose availability differs on this host, e.g. a voice that is not installed. Every field of an entry is optional and absent inherits the provider-level value; a false at either level wins.";
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/$defs/taskAvailability";
+            };
+        };
+    };
+    readonly $defs: {
+        readonly taskAvailability: {
+            readonly title: "ProviderTaskAvailability";
+            readonly description: "The live check for one task kind.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["kind"];
+            readonly properties: {
+                readonly kind: {
+                    readonly description: "The task kind this entry describes.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly available: {
+                    readonly description: "Whether the task can run on this host right now. Absent inherits the provider-level available. Never null.";
+                    readonly type: "boolean";
+                };
+                readonly reason: {
+                    readonly description: "Why the task is unavailable, when available is false.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly streamingAvailable: {
+                    readonly description: "Whether the task can stream on this host right now. Absent inherits. Never null.";
+                    readonly type: "boolean";
+                };
+                readonly streamingUnavailableReason: {
+                    readonly description: "Why streaming is unavailable for this task, when streamingAvailable is false.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly cancellationAvailable: {
+                    readonly description: "Whether cancellation is honored for this task right now. Absent inherits. Never null.";
+                    readonly type: "boolean";
+                };
+                readonly locales: {
+                    readonly description: "BCP 47 locales available for this task right now. Absent means the provider cannot enumerate them.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+                readonly voices: {
+                    readonly description: "Voices available for this task right now. Absent means the provider cannot enumerate them; a request that requires a voice then never routes to it.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/voice";
+                    };
+                };
+            };
+        };
+        readonly voice: {
+            readonly title: "ProviderVoice";
+            readonly description: "Provider-neutral traits of one available voice. Carries no provider voice identifier.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["locale"];
+            readonly properties: {
+                readonly locale: {
+                    readonly description: "BCP 47 locale the voice speaks.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly gender: {
+                    readonly $ref: "#/$defs/voiceGender";
+                };
+                readonly networkRequired: {
+                    readonly description: "Whether using the voice sends data off the device. Absent inherits the task's privacy posture.";
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly voiceGender: {
+            readonly title: "VoiceGender";
+            readonly description: "Perceived gender of a voice, as the platform reports it.";
+            readonly enum: readonly ["female", "male", "neutral"];
+        };
+    };
+};
+export declare const artifactReadRequestSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/artifact-read-request.schema.json";
+    readonly title: "ArtifactReadRequest";
+    readonly description: "A ranged read of an engine-owned media artifact through IndeRunApi.readArtifact (ADR 017). Reads are repeatable until the artifact is disposed; each returns at most the engine's configured maximum read size, which bounds what one call -- and one bridge message -- carries.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["artifactId"];
+    readonly properties: {
+        readonly artifactId: {
+            readonly description: "MediaArtifact.id of the artifact to read.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly offset: {
+            readonly description: "Byte offset to read from. Absent means 0. An offset equal to the artifact's size returns an empty, final chunk; a larger one is rejected.";
+            readonly type: "integer";
+            readonly minimum: 0;
+        };
+        readonly maxBytes: {
+            readonly description: "Most bytes to return. Absent, or larger than the engine's maximum read size, means that maximum.";
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+    };
+};
+export declare const taskOutputSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/task-output.schema.json";
+    readonly title: "TaskOutput";
+    readonly description: "The normalized output of a run, shared by TaskResult and the completed and cancelled stream terminal outcomes (ADR 016). 'type' describes the content representation, not the task: 'text' carries inline text, 'playback' reports a managed, audible effect that has no retrievable bytes, and 'artifact' references retrievable media (ADR 017). A playback output is never an artifact, and an artifact output never implies that anything was played.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["type"];
+    readonly allOf: readonly [{
+        readonly if: {
+            readonly properties: {
+                readonly type: {
+                    readonly const: "text";
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["text"];
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly type: {
+                    readonly const: "playback";
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["playback"];
+        };
+    }, {
+        readonly if: {
+            readonly properties: {
+                readonly type: {
+                    readonly const: "artifact";
+                };
+            };
+        };
+        readonly then: {
+            readonly required: readonly ["artifact"];
+        };
+    }];
+    readonly properties: {
+        readonly type: {
+            readonly title: "TaskOutputType";
+            readonly description: "The content representation: 'text', 'playback' or 'artifact'.";
+            readonly enum: readonly ["text", "playback", "artifact"];
+        };
+        readonly text: {
+            readonly description: "The text the run produced. Required when type is 'text'.";
+            readonly type: "string";
+        };
+        readonly playback: {
+            readonly title: "PlaybackOutput";
+            readonly description: "Completion of managed playback. Required when type is 'playback'. Carries no media.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly durationMs: {
+                    readonly description: "How long audible playback lasted, in milliseconds. For a cancelled run, how long it played before it was stopped.";
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+            };
+        };
+        readonly artifact: {
+            readonly description: "The retrievable media the run produced. Required when type is 'artifact'.";
+            readonly $ref: "media-artifact.schema.json";
+        };
+        readonly speech: {
+            readonly title: "SpeechOutput";
+            readonly description: "The locale and voice traits a text-to-speech run actually used, so an unmet preference is visible without being an error.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["locale"];
+            readonly properties: {
+                readonly locale: {
+                    readonly description: "BCP 47 tag of the locale that was spoken.";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly voice: {
+                    readonly title: "SpeechOutputVoice";
+                    readonly description: "Provider-neutral traits of the voice that spoke. Carries no provider voice identifier.";
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly properties: {
+                        readonly gender: {
+                            readonly $ref: "provider-dynamic-capabilities.schema.json#/$defs/voiceGender";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const mediaArtifactSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/media-artifact.schema.json";
+    readonly title: "MediaArtifact";
+    readonly description: "A reference to retrievable media a run produced (ADR 017). It carries no bytes and no location: an engine-owned artifact is read through the engine by id, and an application-owned one was written to an application destination. Media-neutral: audio, images and video share this shape and differ only in mediaType.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["id", "mediaType", "owner", "lifetime"];
+    readonly properties: {
+        readonly id: {
+            readonly description: "Opaque, engine-issued identifier. Never a path, URL or provider identifier.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly mediaType: {
+            readonly description: "IANA media type of the bytes, e.g. 'audio/wav'. Encoding parameters ride on the media type (e.g. 'audio/L16;rate=22050').";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly owner: {
+            readonly title: "ArtifactOwner";
+            readonly description: "'engine': the engine holds the bytes and the application reads them by id until it disposes the artifact. 'application': the bytes were written to the application destination named by destinationRef and the engine holds nothing.";
+            readonly enum: readonly ["engine", "application"];
+        };
+        readonly lifetime: {
+            readonly title: "ArtifactLifetime";
+            readonly description: "How long the engine keeps the bytes. 'until_disposed': until the application disposes the artifact or the process ends; the artifact outlives the run that produced it.";
+            readonly enum: readonly ["until_disposed"];
+        };
+        readonly byteLength: {
+            readonly description: "Size of the media in bytes. Always set for an artifact the engine materialized.";
+            readonly type: "integer";
+            readonly minimum: 0;
+        };
+        readonly durationMs: {
+            readonly description: "Duration of time-based media in milliseconds, where the producer knows it.";
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        readonly destinationRef: {
+            readonly description: "The request's delivery.destinationRef the bytes were written to. Set exactly when owner is 'application'.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
 export declare const executionProvenanceSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/execution-provenance.schema.json";
@@ -1473,6 +2187,10 @@ export declare const executionProvenanceSchema: {
                         readonly description: "'succeeded' (produced the result or was committed to and completed), 'failed', or 'cancelled'.";
                         readonly enum: readonly ["succeeded", "failed", "cancelled"];
                     };
+                    readonly committed: {
+                        readonly description: "Whether the run committed to this provider during the attempt: its first content was delivered, it signalled the first possible audible effect, or it handed over an artifact. After commit a failure ends the run instead of falling back. Absent means the attempt did not commit.";
+                        readonly type: "boolean";
+                    };
                     readonly errorClass: {
                         readonly description: "Normalized error class of a failed attempt.";
                         readonly enum: readonly ["CapabilityMismatch", "Offline", "AuthError", "RateLimited", "Timeout", "Unavailable", "Internal"];
@@ -1496,7 +2214,7 @@ export declare const executionProvenanceSchema: {
                     readonly codes: {
                         readonly type: "array";
                         readonly items: {
-                            readonly enum: readonly ["task_not_supported", "run_not_supported", "streaming_not_supported", "streaming_unavailable", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable", "not_in_model_profile"];
+                            readonly enum: readonly ["task_not_supported", "run_not_supported", "streaming_not_supported", "streaming_unavailable", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable", "not_in_model_profile", "input_not_supported", "output_delivery_not_supported", "output_format_not_supported", "locale_not_supported", "voice_not_available"];
                         };
                     };
                 };