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

package/dist/core/engine.js

@@ -1,4 +1,4 @@
-import { getTaskRequestValidationIssues } from "@independo/inderun-contracts";
+import { getArtifactReadRequestValidationIssues, getTaskRequestValidationIssues } from "@independo/inderun-contracts";
 import { ProviderRegistry } from "./registry.js";
 import { Router } from "./router.js";
 import { createCapabilityMismatch, createInternal, createUnavailable, toIndeRunException } from "./errors.js";
@@ -6,6 +6,8 @@ import { NoOpTelemetryService } from "./telemetry.js";
 import { EventGate } from "./event-gate.js";
 import { AUTO_MODEL_PROFILE, resolveModelProfile, validateModelProfiles } from "./model-profiles.js";
 import { ProvenanceRecorder } from "./provenance.js";
+import { checkOutput, recheckBoundVoice, taskProfileFor } from "./task-profiles.js";
+import { ArtifactStore } from "./artifacts.js";
 /**
  * Main orchestrator SDK entrypoint class.
  * Validates tasks, executes routing rules based on request constraints and connectivity,
@@ -15,6 +17,7 @@ export class IndeRun {
     registry;
     hostServices;
     router;
+    artifacts;
     telemetryService;
     modelProfiles;
     /**
@@ -32,6 +35,7 @@ export class IndeRun {
             options.telemetryService || this.hostServices.telemetry || new NoOpTelemetryService();
         this.modelProfiles = options.modelProfiles ?? {};
         validateModelProfiles(this.modelProfiles);
+        this.artifacts = new ArtifactStore(options.artifacts);
     }
     /**
      * Validates the request against the schema and resolves its model profile.
@@ -40,6 +44,12 @@ export class IndeRun {
      */
     validateRequest(request, runId) {
         const validationIssues = getTaskRequestValidationIssues(request);
+        if (validationIssues.length === 0 && taskProfileFor(request.task.kind) === undefined) {
+            validationIssues.push({
+                path: "/task/kind",
+                message: `task kind "${request.task.kind}" is not supported by this engine`
+            });
+        }
         if (validationIssues.length === 0) {
             const resolved = resolveModelProfile(this.modelProfiles, request.modelProfile);
             if (resolved.known) {
@@ -133,25 +143,52 @@ export class IndeRun {
         const startTime = this.now();
         const runId = request.requestId || `run_${Math.random().toString(36).substring(2, 11)}`;
         const provenance = new ProvenanceRecorder(request.modelProfile ?? AUTO_MODEL_PROFILE);
+        // The provider a failed run had committed to, which the failure is attributed to.
+        let committedProvider;
         try {
             // 1. Validate request payload using schema contracts and resolve its model profile
             const modelProfile = this.validateRequest(request, runId);
+            await this.checkDestination(request, runId);
             // 2. Select the route based on constraints, model profile, and host capabilities
             const routeSelection = await this.router.selectRoute(request, this.hostServices, "run", modelProfile);
             const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
             provenance.routed(routeSelection.routePlan);
+            const delivery = taskProfileFor(request.task.kind).delivery(request);
             this.emitRouteDecided(runId, request, routeSelection, providers.length);
-            // 3. Execute the run task using the planned provider chain
+            // 3. Execute the run task using the planned provider chain. An attempt that committed
+            // (see RunContext.commit) ends the chain: its failure is the run's failure.
             const attemptedProviderIds = [];
             let lastError;
             for (const [index, provider] of providers.entries()) {
                 const providerId = provider.describe().id;
+                const voice = routeSelection.candidates[index]?.voice;
                 attemptedProviderIds.push(providerId);
+                let committed = false;
+                // Closed when the attempt ends: a provider callback that fires after the run moved
+                // on must not be told it may start, say, audible playback.
+                let attemptOpen = true;
+                const commit = () => {
+                    if (!attemptOpen)
+                        return false;
+                    committed = true;
+                    return true;
+                };
+                const attemptArtifacts = this.artifacts.attempt(commit);
+                let keptArtifactId;
                 try {
+                    const refusal = recheckBoundVoice(request, providerId, voice);
+                    if (refusal !== undefined)
+                        throw refusal;
                     const result = await provider.run(request, {
                         runId,
-                        hostServices: this.hostServices
+                        hostServices: this.hostServices,
+                        ...(voice !== undefined ? { voice } : {}),
+                        commit,
+                        artifacts: attemptArtifacts
                     });
+                    result.output = this.normalizeOutput(request, delivery, result.output, providerId, attemptArtifacts);
+                    result.output = await this.deliverToDestination(request, result.output, providerId);
+                    keptArtifactId = engineOwnedArtifactId(result.output);
                     const endTime = this.now();
                     const totalMs = endTime - startTime;
                     result.runId = runId;
@@ -160,7 +197,7 @@ export class IndeRun {
                         providerUsed: providerId,
                         totalMs
                     };
-                    provenance.attempted(providerId, "succeeded");
+                    provenance.attempted(providerId, "succeeded", undefined, committed);
                     result.provenance = provenance.build(provider.describe(), result.telemetry.reportedModel);
                     this.safeEmit({
                         type: "attempt_succeeded",
@@ -185,8 +222,16 @@ export class IndeRun {
                             routePlan: routeSelection.routePlan
                         }
                     });
-                    provenance.attempted(providerId, "failed", attemptError.errorClass);
+                    provenance.attempted(providerId, "failed", attemptError.errorClass, committed);
                     lastError = attemptError;
+                    if (committed) {
+                        committedProvider = provider;
+                        break;
+                    }
+                }
+                finally {
+                    attemptOpen = false;
+                    attemptArtifacts.release(keptArtifactId);
                 }
             }
             const endTime = this.now();
@@ -213,8 +258,9 @@ export class IndeRun {
             });
             // A routing refusal throws before any attempt; its rejections travel on the details.
             provenance.routingFailed(normalized.details);
-            // No attempt produced the result, so the outcome is attributed to no provider.
-            const exception = normalized.withProvenance(provenance.build());
+            // No attempt produced the result, so the outcome is attributed to no provider -- unless
+            // the run had committed to one, which then owns the failure.
+            const exception = normalized.withProvenance(provenance.build(committedProvider?.describe()));
             const endTime = this.now();
             const totalMs = typeof exception.details?.totalMs === "number"
                 ? exception.details?.totalMs
@@ -259,6 +305,7 @@ export class IndeRun {
         let modelProfile;
         try {
             modelProfile = this.validateRequest(request, runId);
+            await this.checkDestination(request, runId);
         }
         catch (error) {
             throw toIndeRunException(error, { runId }).withProvenance(provenance.build());
@@ -298,19 +345,33 @@ export class IndeRun {
             startedAt: startTime,
             providerId: providers[0].describe().id
         };
+        const delivery = taskProfileFor(request.task.kind).delivery(request);
+        const textRun = delivery === "inline";
+        const artifacts = this.artifacts;
+        const normalizeOutput = this.normalizeOutput.bind(this);
+        const deliverToDestination = this.deliverToDestination.bind(this);
         async function* run() {
             const attemptedProviderIds = [];
+            // Set once, by whichever comes first in an attempt: the provider's commit(), its first
+            // admitted content event, or its result handoff. After it no other provider is tried.
             let committed = false;
-            const cancelledOutcome = (partialText, cancelledProvider) => {
+            // Whether the committed attempt was managed playback that may have been heard.
+            let playbackCommitted = false;
+            const cancelledOutcome = (partialText, cancelledProvider, delivered) => {
                 const reason = typeof controller.signal.reason === "string" ? controller.signal.reason : undefined;
                 if (cancelledProvider !== undefined) {
-                    provenance.attempted(cancelledProvider.describe().id, "cancelled");
+                    provenance.attempted(cancelledProvider.describe().id, "cancelled", undefined, committed);
                 }
                 return {
                     outcome: "cancelled",
                     runId,
                     schemaVersion: "1.0",
-                    partialText,
+                    // A text run reports what it delivered; committed playback reports that it played; an
+                    // artifact already written to its destination is reported, since the application
+                    // owns those bytes now. An uncommitted non-text run produced nothing to report.
+                    ...(textRun ? { partialText } : {}),
+                    ...(playbackCommitted ? { output: { type: "playback", playback: {} } } : {}),
+                    ...(delivered !== undefined ? { output: delivered } : {}),
                     ...(reason !== undefined ? { reason } : {}),
                     provenance: provenance.build(cancelledProvider?.describe())
                 };
@@ -320,6 +381,7 @@ export class IndeRun {
                     break;
                 }
                 const providerId = provider.describe().id;
+                const voice = routeSelection.candidates[index]?.voice;
                 attemptedProviderIds.push(providerId);
                 safeEmit({
                     type: "stream_attempt_started",
@@ -327,12 +389,41 @@ export class IndeRun {
                     timestamp: now(),
                     payload: { providerId, fallbackOccurred: index > 0 }
                 });
+                const markCommitted = () => {
+                    if (committed)
+                        return;
+                    committed = true;
+                    playbackCommitted = delivery === "playback";
+                    safeEmit({
+                        type: "stream_attempt_succeeded",
+                        runId,
+                        timestamp: now(),
+                        payload: { providerId, attemptedProviderIds }
+                    });
+                };
+                // Closed when the attempt ends. A provider callback that fires after the run fell back
+                // must neither start audio nor commit the attempt that replaced this one.
+                let attemptOpen = true;
+                const commit = () => {
+                    if (!attemptOpen || controller.signal.aborted || gate.isTerminated())
+                        return false;
+                    markCommitted();
+                    return true;
+                };
+                const attemptArtifacts = artifacts.attempt(commit);
+                let keptArtifactId;
                 let partialText = "";
                 try {
+                    const refusal = recheckBoundVoice(request, providerId, voice);
+                    if (refusal !== undefined)
+                        throw refusal;
                     const iterable = provider.stream(request, {
                         runId,
                         hostServices: hostServices,
-                        signal: controller.signal
+                        signal: controller.signal,
+                        ...(voice !== undefined ? { voice } : {}),
+                        commit,
+                        artifacts: attemptArtifacts
                     });
                     let terminatedInLoop = false;
                     for await (const ev of iterable) {
@@ -343,16 +434,12 @@ export class IndeRun {
                             throw ev.error;
                         }
                         if (ev.kind === "delta" || ev.kind === "snapshot") {
-                            partialText = ev.kind === "delta" ? partialText + ev.text : ev.text;
-                            if (!committed) {
-                                committed = true;
-                                safeEmit({
-                                    type: "stream_attempt_succeeded",
-                                    runId,
-                                    timestamp: now(),
-                                    payload: { providerId, attemptedProviderIds }
-                                });
+                            // Content events are text-only (ADR 016 §5).
+                            if (!textRun) {
+                                throw checkOutput(request, delivery, { type: "text", text: "" }, providerId);
                             }
+                            partialText = ev.kind === "delta" ? partialText + ev.text : ev.text;
+                            markCommitted();
                             const streamEvent = gate.admit({
                                 timestamp: now(),
                                 type: ev.kind === "delta" ? "content_delta" : "content_snapshot",
@@ -362,16 +449,42 @@ export class IndeRun {
                                 yield streamEvent;
                             continue;
                         }
-                        // ev.kind === "done"
-                        provenance.attempted(providerId, "succeeded");
+                        // ev.kind === "done" (text) or "result" (any task): the run's final output.
+                        const output = normalizeOutput(request, delivery, ev.kind === "done" ? { type: "text", text: ev.finalText } : ev.output, providerId, attemptArtifacts);
+                        markCommitted();
+                        const delivered = await deliverToDestination(request, output, providerId);
+                        // A cancel that landed during the destination write did not interrupt it, but the
+                        // run still ends cancelled. Bytes already at the destination are the application's,
+                        // so the outcome reports them; anything else the usual cancel path below releases.
+                        if (controller.signal.aborted) {
+                            if (delivered.artifact?.owner !== "application")
+                                break;
+                            const terminal = gate.terminate(cancelledOutcome(partialText, provider, delivered), now());
+                            safeEmit({
+                                type: "stream_cancelled",
+                                runId,
+                                timestamp: now(),
+                                payload: { providerId, attemptedProviderIds }
+                            });
+                            terminatedInLoop = true;
+                            if (terminal)
+                                yield terminal;
+                            return;
+                        }
+                        keptArtifactId = engineOwnedArtifactId(delivered);
+                        provenance.attempted(providerId, "succeeded", undefined, committed);
                         const outcome = {
                             outcome: "completed",
                             runId,
                             schemaVersion: "1.0",
-                            finalText: ev.finalText,
+                            ...(ev.kind === "done"
+                                ? { finalText: ev.finalText }
+                                : output.type === "text"
+                                    ? { finalText: output.text, output }
+                                    : { output }),
                             telemetry: { providerUsed: providerId, totalMs: now() - startTime },
                             ...(ev.finishReason !== undefined ? { finishReason: ev.finishReason } : {}),
-                            ...(ev.usage !== undefined ? { usage: ev.usage } : {}),
+                            ...(ev.kind === "done" && ev.usage !== undefined ? { usage: ev.usage } : {}),
                             provenance: provenance.build(provider.describe(), ev.reportedModel)
                         };
                         const terminal = gate.terminate(outcome, now());
@@ -390,6 +503,7 @@ export class IndeRun {
                         return;
                     }
                     if (controller.signal.aborted) {
+                        attemptArtifacts.release();
                         const terminal = gate.terminate(cancelledOutcome(partialText, provider), now());
                         safeEmit({
                             type: "stream_cancelled",
@@ -401,11 +515,12 @@ export class IndeRun {
                             yield terminal;
                         return;
                     }
-                    // Provider's iterable ended without a terminal "done"/"error" event.
+                    // Provider's iterable ended without a terminal "done"/"result"/"error" event.
                     throw new Error(`Provider '${providerId}' stream ended without a terminal event.`);
                 }
                 catch (err) {
                     if (controller.signal.aborted) {
+                        attemptArtifacts.release();
                         const terminal = gate.terminate(cancelledOutcome(partialText, provider), now());
                         safeEmit({
                             type: "stream_cancelled",
@@ -422,7 +537,7 @@ export class IndeRun {
                         runId,
                         details: { attemptedProviderIds }
                     });
-                    provenance.attempted(providerId, "failed", exception.errorClass);
+                    provenance.attempted(providerId, "failed", exception.errorClass, committed);
                     if (!committed) {
                         safeEmit({
                             type: "stream_attempt_failed",
@@ -437,12 +552,13 @@ export class IndeRun {
                         continue;
                     }
                     // Committed: the failure belongs to this provider, not to the chain.
+                    attemptArtifacts.release();
                     const outcome = {
                         outcome: "error",
                         runId,
                         schemaVersion: "1.0",
                         error: exception.toContractError(),
-                        partialText,
+                        ...(textRun ? { partialText } : {}),
                         provenance: provenance.build(provider.describe())
                     };
                     const terminal = gate.terminate(outcome, now());
@@ -461,6 +577,10 @@ export class IndeRun {
                         yield terminal;
                     return;
                 }
+                finally {
+                    attemptOpen = false;
+                    attemptArtifacts.release(keptArtifactId);
+                }
             }
             // Every provider failed pre-commit, or cancellation landed before any attempt started.
             if (controller.signal.aborted) {
@@ -484,7 +604,7 @@ export class IndeRun {
                 runId,
                 schemaVersion: "1.0",
                 error: exception.toContractError(),
-                partialText: "",
+                ...(textRun ? { partialText: "" } : {}),
                 provenance: provenance.build()
             };
             const terminal = gate.terminate(outcome, now());
@@ -507,6 +627,86 @@ export class IndeRun {
      * Reports each registered provider's static descriptor and current dynamic capability check,
      * without executing a task. Useful for UI that shows live provider availability before a run.
      */
+    async readArtifact(request) {
+        const validationIssues = getArtifactReadRequestValidationIssues(request);
+        if (validationIssues.length > 0) {
+            const message = `Validation failed for ArtifactReadRequest: ${validationIssues
+                .map((i) => `${i.path} - ${i.message}`)
+                .join("; ")}`;
+            throw createInternal(message, { details: { validationIssues } });
+        }
+        return this.artifacts.read(request);
+    }
+    async disposeArtifact(artifact) {
+        if (artifact.owner === "engine") {
+            this.artifacts.dispose(artifact.id);
+        }
+    }
+    /**
+     * Refuses, before routing, an artifact request whose `destinationRef` this host cannot
+     * write to: there is no point running a provider whose result has nowhere to go.
+     */
+    async checkDestination(request, runId) {
+        const destinationRef = request.delivery?.destinationRef;
+        if (destinationRef === undefined)
+            return;
+        const destinations = this.hostServices.artifactDestinations;
+        if (destinations === undefined) {
+            throw createCapabilityMismatch("This host has no application artifact destinations.", {
+                runId,
+                details: { code: "artifact_destination_unsupported" }
+            });
+        }
+        if (!(await destinations.accepts(destinationRef, request.delivery?.mediaTypes))) {
+            throw createCapabilityMismatch("The host refused the requested artifact destination.", {
+                runId,
+                details: { code: "artifact_destination_refused" }
+            });
+        }
+    }
+    /**
+     * Writes a finished artifact to the request's application destination, if it names one,
+     * and drops the engine's copy: the result's artifact is then application-owned. The run
+     * has committed by now, so a failed write is the run's failure, never a fallback.
+     */
+    async deliverToDestination(request, output, providerId) {
+        const destinationRef = request.delivery?.destinationRef;
+        const artifact = output.artifact;
+        if (destinationRef === undefined || artifact === undefined)
+            return output;
+        try {
+            await this.hostServices.artifactDestinations.write(destinationRef, artifact, this.artifacts.bytes(artifact.id));
+        }
+        catch {
+            // The host's error stays out of the run's error: it may name the destination.
+            this.artifacts.dispose(artifact.id);
+            throw createInternal("Writing the artifact to its application destination failed.", {
+                providerId,
+                details: { code: "artifact_destination_write_failed" }
+            });
+        }
+        this.artifacts.dispose(artifact.id);
+        return { ...output, artifact: { ...artifact, owner: "application", destinationRef } };
+    }
+    /**
+     * Checks that an artifact in a provider's output is one this attempt produced, swaps in the
+     * reference the store holds, and only then checks the output against the requested delivery:
+     * the artifact's media type, size and ownership are the engine's record rather than the
+     * provider's claim.
+     */
+    normalizeOutput(request, delivery, output, providerId, attemptArtifacts) {
+        let resolved = output;
+        if (output?.artifact !== undefined) {
+            if (!attemptArtifacts.owns(output.artifact.id)) {
+                throw createInternal(`Provider '${providerId}' returned an artifact it did not hand over in this attempt.`, { providerId, details: { code: "output_mismatch" } });
+            }
+            resolved = { ...output, artifact: this.artifacts.reference(output.artifact.id) };
+        }
+        const mismatch = checkOutput(request, delivery, resolved, providerId);
+        if (mismatch !== undefined)
+            throw mismatch;
+        return resolved;
+    }
     async checkCapabilities() {
         return Promise.all(this.registry.list().map(async (provider) => ({
             providerId: provider.describe().id,
@@ -515,3 +715,7 @@ export class IndeRun {
         })));
     }
 }
+/** The id of an artifact output the engine still holds, which an attempt must keep. */
+function engineOwnedArtifactId(output) {
+    return output.artifact?.owner === "engine" ? output.artifact.id : undefined;
+}

package/dist/core/generated/inderun-api.d.ts

@@ -1,17 +1,25 @@
-import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
-import type { StreamRun, ProviderCapabilitySnapshot } from "../provider.js";
+import type { TaskRequest, TaskResult, ProviderCapabilitySnapshot, ArtifactReadRequest, MediaArtifact } from "@independo/inderun-contracts";
+import type { StreamRun, ArtifactChunk } from "../provider.js";
 export interface IndeRunApi {
     /**
-     * Executes a Mode 1 (request/response) text-to-text task against a routed provider and returns the completed TaskResult. Routing (local vs. cloud, which provider) is decided internally from TaskRequest.constraints/preferences — the caller does not select a provider directly. Rejects the request up front on validation failure; otherwise throws an IndeRunException (carrying an IndeRunError) if no eligible provider is found or every attempted provider fails. There is no partial or streaming result in this mode: run() either resolves with a complete TaskResult or throws.
+     * Executes a Mode 1 (request/response) task of any supported kind against a routed provider and returns the completed TaskResult, whose output is text, a managed-playback completion, or a media artifact as the request's delivery asks. Routing (local vs. cloud, which provider) is decided internally from TaskRequest.constraints/preferences — the caller does not select a provider directly. Rejects the request up front on validation failure; otherwise throws an IndeRunException (carrying an IndeRunError) if no eligible provider is found or every attempted provider fails. There is no partial or streaming result in this mode: run() either resolves with a complete TaskResult or throws. A provider failure falls back to the next planned provider unless the attempt had committed (for managed playback, no later than its first possible audible effect); a committed attempt's failure is the run's failure.
      */
     run(request: TaskRequest): Promise<TaskResult>;
     /**
-     * Executes a Mode 2 (streaming) text-to-text task and returns a handle to the run, its canonical StreamEvent sequence, and a cancel hook. The requested interaction mode is a routing input rather than a filter applied after routing: providers that cannot stream are rejected during planning with a normalized reason, so a stream and a run over the same registry may legitimately resolve to different provider chains. Two failure surfaces exist deliberately — validation and route-selection failures reject this call, since there is no handle to correlate them with yet, while provider failure, cancellation, and completion all arrive as the single terminal StreamEvent in the returned sequence. Fallback is narrower than run()'s: a provider failure is only fallback-eligible before the first content event has been delivered; once one has, the run is committed to that provider and a later failure becomes a terminal error rather than a silent provider swap. Cancellation forecloses both at any commit state and always produces exactly one cancelled outcome.
+     * Executes a Mode 2 (streaming) task of any supported kind and returns a handle to the run, its canonical StreamEvent sequence, and a cancel hook. The requested interaction mode is a routing input rather than a filter applied after routing: providers that cannot stream are rejected during planning with a normalized reason, so a stream and a run over the same registry may legitimately resolve to different provider chains. Two failure surfaces exist deliberately — validation and route-selection failures reject this call, since there is no handle to correlate them with yet, while provider failure, cancellation, and completion all arrive as the single terminal StreamEvent in the returned sequence. Fallback is narrower than run()'s: a provider failure is only fallback-eligible before the run commits to that provider -- its first content event, its explicit commit (managed playback, before the first possible audible effect), or its result handoff, whichever comes first; once committed, a later failure becomes a terminal error rather than a silent provider swap. Cancellation forecloses both at any commit state and always produces exactly one cancelled outcome.
      */
     stream(request: TaskRequest): Promise<StreamRun>;
     /**
      * Returns a live snapshot of every registered provider's static descriptor and current dynamic availability, without executing a task or producing any side effects. Call this before run() when you need to show which providers/models are currently available — for example a settings screen or provider picker. Availability can change between calls (a local model can unload, cloud credentials can expire), so don't cache the result across a run() call.
      */
     checkCapabilities(): Promise<ProviderCapabilitySnapshot[]>;
+    /**
+     * Reads a byte range of an engine-owned media artifact a run produced (ADR 017): the bytes in the platform's native byte type, with their offset, the artifact's total size, and whether the range reaches its end. Reads are repeatable until the artifact is disposed, and each returns at most the engine's configured maximum read size. Throws an IndeRunException with errorClass Unavailable and details.code 'artifact_not_found' for an unknown, disposed or application-owned artifact, and a validation error for an offset beyond the end.
+     */
+    readArtifact(request: ArtifactReadRequest): Promise<ArtifactChunk>;
+    /**
+     * Releases the bytes of an engine-owned media artifact. Idempotent: disposing an artifact twice, or one the engine does not hold, does nothing. After disposal readArtifact reports 'artifact_not_found'. An artifact outlives the run that produced it, so an application that keeps none should dispose each one it receives.
+     */
+    disposeArtifact(artifact: MediaArtifact): Promise<void>;
 }
 //# sourceMappingURL=inderun-api.d.ts.map

package/dist/core/generated/inderun-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inderun-api.d.ts","sourceRoot":"","sources":["../../../src/core/generated/inderun-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE5E,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;CAC5D"}
+{"version":3,"file":"inderun-api.d.ts","sourceRoot":"","sources":["../../../src/core/generated/inderun-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5I,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;IAC3D;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnE;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD"}

package/dist/core/host.d.ts

@@ -1,2 +1,2 @@
-export type { AbortSignalLike, ClockService, ConnectivityService, DeviceConstraintsService, HostServices, HttpClientService, HttpRequest, HttpResponse, HttpStreamResponse, HttpStreamingClientService, SecureStorageService, TelemetryService, ThermalState } from "@independo/inderun-contracts";
+export type { AbortSignalLike, ArtifactDestinationService, ClockService, ConnectivityService, DeviceConstraintsService, HostServices, HttpClientService, HttpRequest, HttpResponse, HttpStreamResponse, HttpStreamingClientService, SecureStorageService, TelemetryService, ThermalState } from "@independo/inderun-contracts";
 //# sourceMappingURL=host.d.ts.map

package/dist/core/host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/core/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,EAC1B,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/core/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,EAC1B,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}

package/dist/core/provenance.d.ts

@@ -19,8 +19,11 @@ export declare class ProvenanceRecorder {
     routed(routePlan: SharedPlannerRoutePlan): void;
     /** Records the rejections a routing failure carried out on its exception's details. */
     routingFailed(details: Record<string, unknown> | undefined): void;
-    /** Records how one provider attempt ended. */
-    attempted(providerId: string, outcome: ExecutionProvenanceAttempt["outcome"], errorClass?: IndeRunErrorClass): void;
+    /**
+     * Records how one provider attempt ended, and whether the run had committed to it
+     * (first content delivered, first possible audible effect, or an artifact handed over).
+     */
+    attempted(providerId: string, outcome: ExecutionProvenanceAttempt["outcome"], errorClass?: IndeRunErrorClass, committed?: boolean): void;
     /**
      * Renders the record. `attributedTo` is the provider the outcome belongs to -- the one that
      * produced the result, the one a stream was committed to, or the one running at cancellation --

package/dist/core/provenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/core/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAGjE,KAAK,0BAA0B,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAG1E;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAIjB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAHzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,eAAe,CAAwB;gBAElB,YAAY,GAAE,MAA2B;IAEtE,0FAA0F;IAC1F,MAAM,CAAC,SAAS,EAAE,sBAAsB,GAAG,IAAI;IAI/C,uFAAuF;IACvF,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI;IASjE,8CAA8C;IAC9C,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,EAC9C,UAAU,CAAC,EAAE,iBAAiB,GAC7B,IAAI;IAQP;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,EAAE,kBAAkB,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,mBAAmB;CActF"}
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/core/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAGjE,KAAK,0BAA0B,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAG1E;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAIjB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAHzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,eAAe,CAAwB;gBAElB,YAAY,GAAE,MAA2B;IAEtE,0FAA0F;IAC1F,MAAM,CAAC,SAAS,EAAE,sBAAsB,GAAG,IAAI;IAI/C,uFAAuF;IACvF,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI;IASjE;;;OAGG;IACH,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,0BAA0B,CAAC,SAAS,CAAC,EAC9C,UAAU,CAAC,EAAE,iBAAiB,EAC9B,SAAS,UAAQ,GAChB,IAAI;IASP;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,EAAE,kBAAkB,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,mBAAmB;CActF"}

package/dist/core/provenance.js

@@ -25,11 +25,15 @@ export class ProvenanceRecorder {
             this.routeRejections = routeRejectionsFrom(rejected);
         }
     }
-    /** Records how one provider attempt ended. */
-    attempted(providerId, outcome, errorClass) {
+    /**
+     * Records how one provider attempt ended, and whether the run had committed to it
+     * (first content delivered, first possible audible effect, or an artifact handed over).
+     */
+    attempted(providerId, outcome, errorClass, committed = false) {
         this.attempts.push({
             providerId,
             outcome,
+            ...(committed ? { committed: true } : {}),
             ...(errorClass !== undefined ? { errorClass } : {})
         });
     }