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

package/dist/generated/schemas.d.ts

@@ -413,15 +413,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 +545,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 +553,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 +603,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 +630,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";
@@ -1409,6 +1401,387 @@ 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 executionProvenanceSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/execution-provenance.schema.json";
@@ -1496,7 +1869,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"];
                         };
                     };
                 };

package/dist/generated/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/generated/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsMpB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHnB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DrB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CvB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8N1B,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6HlB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KrB,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiClB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAydpB,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsN9B,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuI5B,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/generated/schemas.ts"],"names":[],"mappings":"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"}