@independo/inderun-contracts 0.2.2 → 0.3.0-dev.10

package/dist/generated/schemas.d.ts

@@ -366,7 +366,7 @@ export declare const telemetryEventSchema: {
     readonly properties: {
         readonly type: {
             readonly description: "Telemetry event kind emitted by the orchestrator or provider integration.";
-            readonly enum: readonly ["route_decided", "attempt_succeeded", "attempt_failed"];
+            readonly enum: readonly ["route_decided", "attempt_succeeded", "attempt_failed", "stream_attempt_started", "stream_attempt_succeeded", "stream_attempt_failed", "stream_completed", "stream_failed", "stream_cancelled"];
         };
         readonly runId: {
             readonly description: "Opaque run identifier associated with this execution event.";
@@ -389,7 +389,7 @@ export declare const routePlannerInputSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://schemas.inderun.dev/1.0/route-planner-input.schema.json";
     readonly title: "RoutePlannerInput";
-    readonly description: "Pure data input contract for deterministic shared-core Mode-1 route planning.";
+    readonly description: "Pure data input contract for deterministic shared-core route planning.";
     readonly type: "object";
     readonly additionalProperties: true;
     readonly required: readonly ["task", "constraints", "preferences", "providers"];
@@ -406,6 +406,10 @@ export declare const routePlannerInputSchema: {
                 };
             };
         };
+        readonly interactionMode: {
+            readonly description: "Interaction mode the caller is requesting. Absent means 'run' (Mode 1), so planner inputs produced before this field existed keep their exact Mode-1 semantics. The mode filters eligible providers; it never changes candidate ordering.";
+            readonly enum: readonly ["run", "stream"];
+        };
         readonly constraints: {
             readonly description: "Hard routing constraints evaluated before provider selection.";
             readonly type: "object";
@@ -464,8 +468,16 @@ export declare const routePlannerInputSchema: {
                                     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: {
@@ -505,6 +517,19 @@ export declare const routePlannerInputSchema: {
                                 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";
+                            };
                         };
                     };
                 };
@@ -573,7 +598,8 @@ export declare const routePlanSchema: {
                             readonly required: readonly ["code", "message"];
                             readonly properties: {
                                 readonly code: {
-                                    readonly enum: readonly ["task_not_supported", "run_not_supported", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable"];
+                                    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.";
+                                    readonly enum: readonly ["task_not_supported", "run_not_supported", "streaming_not_supported", "streaming_unavailable", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable"];
                                 };
                                 readonly message: {
                                     readonly type: "string";
@@ -765,4 +791,550 @@ export declare const modelPackageSchema: {
         };
     };
 };
+export declare const streamRunSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/stream-run.schema.json";
+    readonly title: "StreamRunHandle";
+    readonly description: "The serializable acknowledgment returned when a Mode 2 stream is opened, before any StreamEvent has arrived. This is the identity/correlation contract only: the live, consumable stream itself is a platform-idiomatic construct (an AsyncIterable<StreamEvent> in TypeScript, a Flow<StreamEvent> in Kotlin, an AsyncThrowingStream<StreamEvent, Error> in Swift) that is never serialized and is out of scope for this schema. Design seam only; no engine or provider implementation exists yet (see docs/architecture/architecture.md).";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["schemaVersion", "runId", "startedAt"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly description: "Contract schema version used to interpret this handle payload.";
+            readonly const: "1.0";
+        };
+        readonly runId: {
+            readonly description: "A unique, opaque identifier assigned by the engine for this stream run. Every StreamEvent and the terminal StreamTerminalOutcome for this run carry the same runId, matching the identity convention used by TaskResult.runId and IndeRunError.runId.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly startedAt: {
+            readonly description: "Wall-clock time the stream run was opened, in Unix epoch milliseconds.";
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        readonly providerId: {
+            readonly description: "Identifier of the provider selected to service this stream, if routing has completed by the time the handle is returned. Absent while route selection is still pending.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+export declare const streamEventSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/stream-event.schema.json";
+    readonly title: "StreamEvent";
+    readonly description: "The canonical Mode 2 streaming event union, discriminated by 'type'. Every variant shares an envelope of schemaVersion, runId, sequence, timestamp, and type. 'sequence' is the ordering authority for events within a run (a monotonically increasing integer starting at 0 per runId) — consumers must order by 'sequence', not by arrival order, since a bridge hop (e.g. a future Capacitor bridge) could reorder delivery. Known event types are split into user-visible content ('content_delta', 'content_snapshot') and mechanical/diagnostic types ('lifecycle', 'diagnostic', 'terminal') so SDKs can distinguish what belongs in a chat UI from what is orchestration detail. Forward compatibility: this union closes with an open 'unknown_event' branch so a consumer built against an older revision of this schema does not hard-fail when a newer, additive minor revision introduces a new known type; per contracts/README.md's schema evolution policy, SDKs must treat an unrecognized 'type' as ignore-or-pass-through-for-diagnostics, never as a hard error. Design seam only; no engine or provider implementation exists yet (see docs/architecture/architecture.md).";
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type", "payload"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. The ordering authority; do not rely on delivery/arrival order.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "User-visible content: an incremental text increment since the previous content_delta or content_snapshot event. Mirrors ProviderDescriptor.streamingStyle 'tokens'/'chunks' (packages/inderun-web/src/core/provider.ts) — providers reporting either style normalize to content_delta.";
+                readonly const: "content_delta";
+            };
+            readonly payload: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["text"];
+                readonly properties: {
+                    readonly text: {
+                        readonly description: "The incremental text produced since the previous content event.";
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type", "payload"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. The ordering authority; do not rely on delivery/arrival order.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "User-visible content: the full cumulative text produced so far. Mirrors ProviderDescriptor.streamingStyle 'snapshots' (packages/inderun-web/src/core/provider.ts) — providers reporting that style normalize to content_snapshot rather than content_delta.";
+                readonly const: "content_snapshot";
+            };
+            readonly payload: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["text"];
+                readonly properties: {
+                    readonly text: {
+                        readonly description: "The full cumulative text produced by the run so far.";
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type", "payload"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. The ordering authority; do not rely on delivery/arrival order.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "Mechanical/diagnostic: a run lifecycle transition (e.g. provider selection, execution start). Not user-visible content; not part of the generated text.";
+                readonly const: "lifecycle";
+            };
+            readonly payload: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["phase"];
+                readonly properties: {
+                    readonly phase: {
+                        readonly description: "The lifecycle phase reached.";
+                        readonly enum: readonly ["provider_selected", "started"];
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type", "payload"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. The ordering authority; do not rely on delivery/arrival order.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "Mechanical/diagnostic: free-form orchestration or provider diagnostic detail. Not user-visible content.";
+                readonly const: "diagnostic";
+            };
+            readonly payload: {
+                readonly description: "Event-specific diagnostic metadata. It must not contain prompt payloads or raw secrets, matching the same guardrail as TelemetryEvent.payload.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type", "payload"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. This is always the highest sequence number for the run: the terminal event.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "Terminal: the last event of the run, carrying the mutually-exclusive completion/error/cancellation outcome. No further StreamEvent is delivered for this runId after this event.";
+                readonly const: "terminal";
+            };
+            readonly payload: {
+                readonly description: "Structurally identical to StreamTerminalOutcome (contracts/schemas/stream-terminal-outcome.schema.json), duplicated by value here rather than by $ref, matching this repo's schema convention of no cross-file references. Keep both shapes in sync; a cross-check test asserts a shared fixture validates against both schemas.";
+                readonly oneOf: readonly [{
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["schemaVersion", "runId", "outcome", "finalText"];
+                    readonly properties: {
+                        readonly schemaVersion: {
+                            readonly const: "1.0";
+                        };
+                        readonly runId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly outcome: {
+                            readonly const: "completed";
+                        };
+                        readonly finalText: {
+                            readonly type: "string";
+                        };
+                        readonly finishReason: {
+                            readonly enum: readonly ["stop", "length", "cancelled", "error"];
+                        };
+                        readonly usage: {
+                            readonly type: "object";
+                            readonly additionalProperties: true;
+                            readonly properties: {
+                                readonly inputTokens: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                                readonly outputTokens: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                                readonly totalTokens: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                            };
+                        };
+                        readonly telemetry: {
+                            readonly type: "object";
+                            readonly additionalProperties: true;
+                            readonly required: readonly ["providerUsed", "totalMs"];
+                            readonly properties: {
+                                readonly providerUsed: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly totalMs: {
+                                    readonly type: "number";
+                                    readonly minimum: 0;
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["schemaVersion", "runId", "outcome", "error"];
+                    readonly properties: {
+                        readonly schemaVersion: {
+                            readonly const: "1.0";
+                        };
+                        readonly runId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly outcome: {
+                            readonly const: "error";
+                        };
+                        readonly error: {
+                            readonly type: "object";
+                            readonly additionalProperties: true;
+                            readonly required: readonly ["schemaVersion", "errorClass", "message"];
+                            readonly properties: {
+                                readonly schemaVersion: {
+                                    readonly const: "1.0";
+                                };
+                                readonly errorClass: {
+                                    readonly enum: readonly ["CapabilityMismatch", "Offline", "AuthError", "RateLimited", "Timeout", "Unavailable", "Internal"];
+                                };
+                                readonly message: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly providerId: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly retryable: {
+                                    readonly type: "boolean";
+                                };
+                                readonly retryAfterMs: {
+                                    readonly type: "integer";
+                                    readonly minimum: 0;
+                                };
+                                readonly details: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: true;
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly required: readonly ["schemaVersion", "runId", "outcome", "partialText"];
+                    readonly properties: {
+                        readonly schemaVersion: {
+                            readonly const: "1.0";
+                        };
+                        readonly runId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly outcome: {
+                            readonly const: "cancelled";
+                        };
+                        readonly partialText: {
+                            readonly type: "string";
+                        };
+                        readonly reason: {
+                            readonly type: "string";
+                        };
+                    };
+                }];
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "sequence", "timestamp", "type"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this event payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "Opaque run identifier this event belongs to, matching StreamRunHandle.runId.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly sequence: {
+                readonly description: "Zero-based, monotonically increasing event index within this run. The ordering authority; do not rely on delivery/arrival order.";
+                readonly type: "integer";
+                readonly minimum: 0;
+            };
+            readonly timestamp: {
+                readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+                readonly type: "number";
+                readonly minimum: 0;
+            };
+            readonly type: {
+                readonly description: "Forward-compatibility catch-all: any event type not among the known constants above. Exists so a consumer validating against this revision of the schema does not hard-fail when a future additive revision introduces a new known event type; SDKs must ignore or pass through such events for diagnostics rather than treating them as an error.";
+                readonly type: "string";
+                readonly not: {
+                    readonly enum: readonly ["content_delta", "content_snapshot", "lifecycle", "diagnostic", "terminal"];
+                };
+            };
+            readonly payload: {
+                readonly description: "Optional event-specific payload for the unrecognized type. It must not contain prompt payloads or raw secrets.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
+        };
+    }];
+};
+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 oneOf: readonly [{
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "outcome", "finalText"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this outcome payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "The stream run this outcome terminates, matching StreamRunHandle.runId and every StreamEvent.runId for the run.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly outcome: {
+                readonly description: "The stream completed normally: every provider-generated event was delivered before this outcome was produced.";
+                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 type: "string";
+            };
+            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"];
+            };
+            readonly usage: {
+                readonly description: "Optional metadata regarding the quantity of tokens processed by the provider. Same shape as TaskResult.usage.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly properties: {
+                    readonly inputTokens: {
+                        readonly description: "Number of input tokens consumed, as reported by the provider.";
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly outputTokens: {
+                        readonly description: "Number of output tokens generated, as reported by the provider.";
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly totalTokens: {
+                        readonly description: "Aggregated token count for this request, as reported by the provider.";
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                };
+            };
+            readonly telemetry: {
+                readonly description: "Required metadata providing an overview of the execution result and performance metrics. Same shape as TaskResult.telemetry.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["providerUsed", "totalMs"];
+                readonly properties: {
+                    readonly providerUsed: {
+                        readonly description: "The identifier for the specific provider that handled the request (e.g., 'openai_compatible_cloud').";
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly totalMs: {
+                        readonly description: "Measured execution duration in milliseconds, including route selection and result processing.";
+                        readonly type: "number";
+                        readonly minimum: 0;
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "outcome", "error"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this outcome payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "The stream run this outcome terminates, matching StreamRunHandle.runId and every StreamEvent.runId for the run.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly outcome: {
+                readonly description: "The stream ended in failure: validation, routing (no eligible provider), or every attempted provider failing.";
+                readonly const: "error";
+            };
+            readonly error: {
+                readonly description: "The normalized error for this failure. Structurally identical to IndeRunError (contracts/schemas/inderun-error.schema.json), duplicated by value here rather than by $ref, matching this repo's schema convention of no cross-file references. Keep both shapes in sync; a cross-check test asserts a shared fixture validates against both schemas.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["schemaVersion", "errorClass", "message"];
+                readonly properties: {
+                    readonly schemaVersion: {
+                        readonly description: "Contract schema version used to interpret the error payload.";
+                        readonly const: "1.0";
+                    };
+                    readonly errorClass: {
+                        readonly description: "Normalized error taxonomy, identical to IndeRunError.errorClass: CapabilityMismatch (request needs something no eligible provider supports), Offline/Unavailable (provider unreachable or not ready), AuthError (credential/auth failure), RateLimited (provider throttled the request), Timeout (provider exceeded its execution budget), Internal (unexpected engine-side failure).";
+                        readonly enum: readonly ["CapabilityMismatch", "Offline", "AuthError", "RateLimited", "Timeout", "Unavailable", "Internal"];
+                    };
+                    readonly message: {
+                        readonly description: "Human-readable error message suitable for logs and developer diagnostics.";
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly providerId: {
+                        readonly description: "Identifier of the provider associated with the failure, if execution reached a provider.";
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly retryable: {
+                        readonly description: "Whether retrying the same request may succeed.";
+                        readonly type: "boolean";
+                    };
+                    readonly retryAfterMs: {
+                        readonly description: "Optional suggested delay before retrying, in milliseconds.";
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly details: {
+                        readonly description: "Optional structured diagnostic details. It must not contain raw secrets.";
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly additionalProperties: true;
+        readonly required: readonly ["schemaVersion", "runId", "outcome", "partialText"];
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly description: "Contract schema version used to interpret this outcome payload.";
+                readonly const: "1.0";
+            };
+            readonly runId: {
+                readonly description: "The stream run this outcome terminates, matching StreamRunHandle.runId and every StreamEvent.runId for the run.";
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly outcome: {
+                readonly description: "The stream was cancelled. No further StreamEvent is delivered after this outcome, and no further fallback attempt is made, per the engine's cancellation guarantee.";
+                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 type: "string";
+            };
+            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";
+            };
+        };
+    }];
+};
 //# sourceMappingURL=schemas.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiMpB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GnB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DrB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCvB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqK1B,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHlB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KrB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/generated/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiMpB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GnB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DrB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CvB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqM1B,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HlB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KrB,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiClB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAycpB,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsM9B,CAAC"}