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

package/src/core/engine.ts

@@ -19,6 +19,14 @@ import {
 } from "./errors.js";
 import { type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./telemetry.js";
 import { EventGate } from "./event-gate.js";
+import {
+  AUTO_MODEL_PROFILE,
+  type ModelProfiles,
+  type ResolvedModelProfile,
+  resolveModelProfile,
+  validateModelProfiles
+} from "./model-profiles.js";
+import { ProvenanceRecorder } from "./provenance.js";
 
 /**
  * @deprecated Renamed to `StreamRun`, which is the name the generated
@@ -27,6 +35,22 @@ import { EventGate } from "./event-gate.js";
  */
 export type StreamHandleResult = StreamRun;
 
+/**
+ * Optional engine configuration.
+ */
+export interface IndeRunOptions {
+  /**
+   * Telemetry listener. Defaults to the host's telemetry service, then to a no-op.
+   */
+  telemetryService?: TelemetryService;
+  /**
+   * Named model profiles requests can route within (`TaskRequest.modelProfile`).
+   * Each maps a profile name to an ordered list of target (provider instance) ids.
+   * `"auto"` is built in and cannot be redefined. See `docs/architecture/api-layering.md`.
+   */
+  modelProfiles?: ModelProfiles;
+}
+
 /**
  * Main orchestrator SDK entrypoint class.
  * Validates tasks, executes routing rules based on request constraints and connectivity,
@@ -35,21 +59,48 @@ export type StreamHandleResult = StreamRun;
 export class IndeRun implements IndeRunApi {
   private router: Router;
   private telemetryService: TelemetryService;
+  private modelProfiles: ModelProfiles;
 
   /**
    * Initializes the IndeRun instance.
    * @param registry - Registry filled with active providers.
    * @param hostServices - Services wrapping OS interfaces and indicators.
-   * @param telemetryService - Optional custom telemetry service listener.
+   * @param options - Optional telemetry listener and model profiles.
+   * @throws {Error} If a model profile is malformed (see {@link validateModelProfiles}).
    */
   constructor(
     private registry: ProviderRegistry,
     private hostServices: HostServices,
-    telemetryService?: TelemetryService
+    options: IndeRunOptions = {}
   ) {
     this.router = new Router(this.registry);
     this.telemetryService =
-      telemetryService || this.hostServices.telemetry || new NoOpTelemetryService();
+      options.telemetryService || this.hostServices.telemetry || new NoOpTelemetryService();
+    this.modelProfiles = options.modelProfiles ?? {};
+    validateModelProfiles(this.modelProfiles);
+  }
+
+  /**
+   * Validates the request against the schema and resolves its model profile.
+   * Both failures are request validation errors: they are reported before any
+   * provider is probed, with the offending fields in `details.validationIssues`.
+   */
+  private validateRequest(request: TaskRequest, runId: string): ResolvedModelProfile {
+    const validationIssues = getTaskRequestValidationIssues(request);
+    if (validationIssues.length === 0) {
+      const resolved = resolveModelProfile(this.modelProfiles, request.modelProfile);
+      if (resolved.known) {
+        return resolved.profile;
+      }
+      validationIssues.push({
+        path: "/modelProfile",
+        message: `unknown model profile "${request.modelProfile}"; configure it in the engine's modelProfiles`
+      });
+    }
+    const message = `Validation failed for TaskRequest: ${validationIssues
+      .map((i) => `${i.path} - ${i.message}`)
+      .join("; ")}`;
+    throw createInternal(message, { runId, details: { validationIssues } });
   }
 
   /**
@@ -81,6 +132,7 @@ export class IndeRun implements IndeRunApi {
         rejectedProviders: routeSelection.routePlan.rejectedProviders,
         fallbackAvailable: providerCount > 1,
         taskKind: request.task.kind,
+        modelProfile: request.modelProfile ?? "auto",
         constraints: request.constraints ?? null,
         preferences: request.preferences ?? null,
         explanation: routeSelection.explanation
@@ -137,23 +189,21 @@ export class IndeRun implements IndeRunApi {
     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);
 
     try {
-      // 1. Validate request payload using schema contracts
-      const validationIssues = getTaskRequestValidationIssues(request);
-      if (validationIssues.length > 0) {
-        const message = `Validation failed for TaskRequest: ${validationIssues
-          .map((i) => `${i.path} - ${i.message}`)
-          .join("; ")}`;
-        throw createInternal(message, {
-          runId,
-          details: { validationIssues }
-        });
-      }
-
-      // 2. Select the route based on constraints and host capabilities
-      const routeSelection = await this.router.selectRoute(request, this.hostServices, "run");
+      // 1. Validate request payload using schema contracts and resolve its model profile
+      const modelProfile = this.validateRequest(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);
 
       this.emitRouteDecided(runId, request, routeSelection, providers.length);
 
@@ -179,6 +229,8 @@ export class IndeRun implements IndeRunApi {
             providerUsed: providerId,
             totalMs
           };
+          provenance.attempted(providerId, "succeeded");
+          result.provenance = provenance.build(provider.describe(), result.telemetry.reportedModel);
 
           this.safeEmit({
             type: "attempt_succeeded",
@@ -194,7 +246,7 @@ export class IndeRun implements IndeRunApi {
 
           return result;
         } catch (err) {
-          lastError = toIndeRunException(err, {
+          const attemptError = toIndeRunException(err, {
             providerId,
             runId,
             details: {
@@ -203,6 +255,8 @@ export class IndeRun implements IndeRunApi {
               routePlan: routeSelection.routePlan
             }
           });
+          provenance.attempted(providerId, "failed", attemptError.errorClass);
+          lastError = attemptError;
         }
       }
 
@@ -213,14 +267,14 @@ export class IndeRun implements IndeRunApi {
         details: {
           totalMs,
           attemptedProviderIds,
-          fallbackOccurred: providers.length > 1,
+          fallbackOccurred: attemptedProviderIds.length > 1,
           routePlan: routeSelection.routePlan
         }
       });
 
       throw exception;
     } catch (error) {
-      const exception = toIndeRunException(error, {
+      const normalized = toIndeRunException(error, {
         runId,
         details: {
           totalMs:
@@ -229,6 +283,10 @@ export class IndeRun implements IndeRunApi {
               : this.now() - startTime
         }
       });
+      // 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());
       const endTime = this.now();
       const totalMs =
         typeof (exception as { details?: { totalMs?: number } }).details?.totalMs === "number"
@@ -273,13 +331,13 @@ export class IndeRun implements IndeRunApi {
     const startTime = this.now();
     const now = () => this.now();
     const runId = request.requestId || `run_${Math.random().toString(36).substring(2, 11)}`;
+    const provenance = new ProvenanceRecorder(request.modelProfile ?? AUTO_MODEL_PROFILE);
 
-    const validationIssues = getTaskRequestValidationIssues(request);
-    if (validationIssues.length > 0) {
-      const message = `Validation failed for TaskRequest: ${validationIssues
-        .map((i) => `${i.path} - ${i.message}`)
-        .join("; ")}`;
-      throw createInternal(message, { runId, details: { validationIssues } });
+    let modelProfile: ResolvedModelProfile;
+    try {
+      modelProfile = this.validateRequest(request, runId);
+    } catch (error) {
+      throw toIndeRunException(error, { runId }).withProvenance(provenance.build());
     }
 
     // Route selection failures are the one class of stream error that surfaces as a
@@ -287,11 +345,19 @@ export class IndeRun implements IndeRunApi {
     // runId — there is no handle for the caller to correlate them with otherwise.
     let routeSelection: RouteSelection;
     try {
-      routeSelection = await this.router.selectRoute(request, this.hostServices, "stream");
+      routeSelection = await this.router.selectRoute(
+        request,
+        this.hostServices,
+        "stream",
+        modelProfile
+      );
     } catch (error) {
-      throw toIndeRunException(error, { runId });
+      const exception = toIndeRunException(error, { runId });
+      provenance.routingFailed(exception.details);
+      throw exception.withProvenance(provenance.build());
     }
     const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
+    provenance.routed(routeSelection.routePlan);
 
     this.emitRouteDecided(runId, request, routeSelection, providers.length);
 
@@ -322,15 +388,22 @@ export class IndeRun implements IndeRunApi {
       const attemptedProviderIds: string[] = [];
       let committed = false;
 
-      const cancelledOutcome = (partialText: string): StreamTerminalOutcome => {
+      const cancelledOutcome = (
+        partialText: string,
+        cancelledProvider?: ProviderAdapter
+      ): StreamTerminalOutcome => {
         const reason =
           typeof controller.signal.reason === "string" ? controller.signal.reason : undefined;
+        if (cancelledProvider !== undefined) {
+          provenance.attempted(cancelledProvider.describe().id, "cancelled");
+        }
         return {
           outcome: "cancelled",
           runId,
           schemaVersion: "1.0",
           partialText,
-          ...(reason !== undefined ? { reason } : {})
+          ...(reason !== undefined ? { reason } : {}),
+          provenance: provenance.build(cancelledProvider?.describe())
         };
       };
 
@@ -387,6 +460,7 @@ export class IndeRun implements IndeRunApi {
             }
 
             // ev.kind === "done"
+            provenance.attempted(providerId, "succeeded");
             const outcome: StreamTerminalOutcome = {
               outcome: "completed",
               runId,
@@ -394,7 +468,8 @@ export class IndeRun implements IndeRunApi {
               finalText: ev.finalText,
               telemetry: { providerUsed: providerId, totalMs: now() - startTime },
               ...(ev.finishReason !== undefined ? { finishReason: ev.finishReason } : {}),
-              ...(ev.usage !== undefined ? { usage: ev.usage } : {})
+              ...(ev.usage !== undefined ? { usage: ev.usage } : {}),
+              provenance: provenance.build(provider.describe(), ev.reportedModel)
             };
             const terminal = gate.terminate(outcome, now());
             safeEmit({
@@ -413,7 +488,7 @@ export class IndeRun implements IndeRunApi {
           }
 
           if (controller.signal.aborted) {
-            const terminal = gate.terminate(cancelledOutcome(partialText), now());
+            const terminal = gate.terminate(cancelledOutcome(partialText, provider), now());
             safeEmit({
               type: "stream_cancelled",
               runId,
@@ -428,7 +503,7 @@ export class IndeRun implements IndeRunApi {
           throw new Error(`Provider '${providerId}' stream ended without a terminal event.`);
         } catch (err) {
           if (controller.signal.aborted) {
-            const terminal = gate.terminate(cancelledOutcome(partialText), now());
+            const terminal = gate.terminate(cancelledOutcome(partialText, provider), now());
             safeEmit({
               type: "stream_cancelled",
               runId,
@@ -444,6 +519,7 @@ export class IndeRun implements IndeRunApi {
             runId,
             details: { attemptedProviderIds }
           });
+          provenance.attempted(providerId, "failed", exception.errorClass);
 
           if (!committed) {
             safeEmit({
@@ -459,12 +535,14 @@ export class IndeRun implements IndeRunApi {
             continue;
           }
 
+          // Committed: the failure belongs to this provider, not to the chain.
           const outcome: StreamTerminalOutcome = {
             outcome: "error",
             runId,
             schemaVersion: "1.0",
             error: exception.toContractError(),
-            partialText
+            partialText,
+            provenance: provenance.build(provider.describe())
           };
           const terminal = gate.terminate(outcome, now());
           safeEmit({
@@ -505,7 +583,8 @@ export class IndeRun implements IndeRunApi {
         runId,
         schemaVersion: "1.0",
         error: exception.toContractError(),
-        partialText: ""
+        partialText: "",
+        provenance: provenance.build()
       };
       const terminal = gate.terminate(outcome, now());
       safeEmit({

package/src/core/errors.ts

@@ -1,4 +1,8 @@
-import type { IndeRunError, IndeRunErrorClass } from "@independo/inderun-contracts";
+import type {
+  ExecutionProvenance,
+  IndeRunError,
+  IndeRunErrorClass
+} from "@independo/inderun-contracts";
 
 /**
  * Parameter structure required to initialize an IndeRunException.
@@ -32,6 +36,10 @@ export interface IndeRunExceptionParams {
    * Rich contextual metadata regarding the error.
    */
   details?: Record<string, unknown>;
+  /**
+   * How the failed execution played out, attached by the engine.
+   */
+  provenance?: ExecutionProvenance;
 }
 
 /**
@@ -53,6 +61,8 @@ export class IndeRunException extends Error {
   readonly retryAfterMs?: number;
   /** Custom details and metadata context. */
   readonly details?: Record<string, unknown>;
+  /** How the failed execution played out: attempts, rejections, the provider committed to. */
+  readonly provenance?: ExecutionProvenance;
 
   constructor(params: IndeRunExceptionParams) {
     super(params.message);
@@ -63,6 +73,7 @@ export class IndeRunException extends Error {
     if (params.retryable !== undefined) this.retryable = params.retryable;
     if (params.retryAfterMs !== undefined) this.retryAfterMs = params.retryAfterMs;
     if (params.details !== undefined) this.details = params.details;
+    if (params.provenance !== undefined) this.provenance = params.provenance;
 
     Object.setPrototypeOf(this, IndeRunException.prototype);
   }
@@ -81,8 +92,28 @@ export class IndeRunException extends Error {
     if (this.retryable !== undefined) err.retryable = this.retryable;
     if (this.retryAfterMs !== undefined) err.retryAfterMs = this.retryAfterMs;
     if (this.details !== undefined) err.details = this.details;
+    if (this.provenance !== undefined) err.provenance = this.provenance;
     return err;
   }
+
+  /**
+   * A copy of this exception carrying `provenance`. The engine attaches provenance once it
+   * knows how the whole execution ended, replacing anything set earlier.
+   */
+  withProvenance(provenance: ExecutionProvenance): IndeRunException {
+    return new IndeRunException({ ...this.params(), provenance });
+  }
+
+  private params(): IndeRunExceptionParams {
+    const params: IndeRunExceptionParams = { errorClass: this.errorClass, message: this.message };
+    if (this.runId !== undefined) params.runId = this.runId;
+    if (this.providerId !== undefined) params.providerId = this.providerId;
+    if (this.retryable !== undefined) params.retryable = this.retryable;
+    if (this.retryAfterMs !== undefined) params.retryAfterMs = this.retryAfterMs;
+    if (this.details !== undefined) params.details = this.details;
+    if (this.provenance !== undefined) params.provenance = this.provenance;
+    return params;
+  }
 }
 
 /**
@@ -189,6 +220,9 @@ export function toIndeRunException(
         };
       }
 
+      const provenance = error.provenance ?? fallbackParams.provenance;
+      if (provenance !== undefined) mergedParams.provenance = provenance;
+
       return new IndeRunException(mergedParams);
     }
     return error;

package/src/core/model-profiles.ts

@@ -0,0 +1,70 @@
+import type { SharedPlannerInput } from "./route-planner.js";
+
+/**
+ * The built-in profile: every registered target, ranked by constraints and
+ * preferences alone. Requests that name no profile route within it.
+ */
+export const AUTO_MODEL_PROFILE = "auto";
+
+/**
+ * Application-defined model profiles: a profile name mapped to an ordered list of
+ * target ids (provider instance ids, each bound to one model). Requests name a
+ * profile through `TaskRequest.modelProfile`; the route planner treats the list as
+ * an allow-list and ranks its entries after placement and before preferences.
+ * Ids that name no registered provider are ignored by the planner.
+ */
+export type ModelProfiles = Readonly<Record<string, readonly string[]>>;
+
+/** A resolved profile as the shared planner consumes it; absent means `auto`. */
+export type ResolvedModelProfile = SharedPlannerInput["modelProfile"];
+
+/**
+ * Checks profile configuration once, when the engine is constructed, so a
+ * malformed profile is a setup error rather than a per-request surprise.
+ * @throws {Error} When a profile is named `auto`, is empty, or lists a target twice.
+ */
+export function validateModelProfiles(profiles: ModelProfiles): void {
+  for (const [name, targetIds] of Object.entries(profiles)) {
+    if (name.length === 0) {
+      throw new Error("Model profile names must be non-empty.");
+    }
+    if (name === AUTO_MODEL_PROFILE) {
+      throw new Error(
+        `"${AUTO_MODEL_PROFILE}" is the built-in model profile and cannot be redefined.`
+      );
+    }
+    if (targetIds.length === 0) {
+      throw new Error(`Model profile "${name}" must list at least one target id.`);
+    }
+    const seen = new Set<string>();
+    for (const id of targetIds) {
+      if (id.length === 0) {
+        throw new Error(`Model profile "${name}" lists an empty target id.`);
+      }
+      if (seen.has(id)) {
+        throw new Error(`Model profile "${name}" lists target "${id}" more than once.`);
+      }
+      seen.add(id);
+    }
+  }
+}
+
+/**
+ * Resolves a request's profile name against the configured profiles.
+ * @returns `{ known: true }` with the planner input (undefined for `auto`), or
+ *   `{ known: false }` when the name matches no configured profile.
+ */
+export function resolveModelProfile(
+  profiles: ModelProfiles,
+  name: string | undefined
+): { known: true; profile: ResolvedModelProfile } | { known: false } {
+  if (name === undefined || name === AUTO_MODEL_PROFILE) {
+    return { known: true, profile: undefined };
+  }
+  if (!Object.hasOwn(profiles, name)) {
+    return { known: false };
+  }
+  // validateModelProfiles guarantees every configured profile is non-empty.
+  const [first, ...rest] = profiles[name]!;
+  return { known: true, profile: { name, targetIds: [first!, ...rest] } };
+}

package/src/core/provenance.ts

@@ -0,0 +1,90 @@
+import type { ExecutionProvenance, IndeRunErrorClass } from "@independo/inderun-contracts";
+import type { ProviderDescriptor } from "./provider.js";
+import type { SharedPlannerRoutePlan } from "./route-planner.js";
+import { AUTO_MODEL_PROFILE } from "./model-profiles.js";
+
+type ExecutionProvenanceAttempt = ExecutionProvenance["attempts"][number];
+type RouteRejection = ExecutionProvenance["routeRejections"][number];
+
+/**
+ * Accumulates what one execution did -- each attempt and how it ended -- and renders it as the
+ * normalized {@link ExecutionProvenance} carried on results, terminal outcomes, and errors.
+ *
+ * Everything recorded is either observed by the engine (attempts, their outcomes) or declared or
+ * reported by a provider (descriptor type and model, the model a response names). Nothing is
+ * inferred: an unknown is left absent or reported as `unknown`.
+ */
+export class ProvenanceRecorder {
+  private readonly attempts: ExecutionProvenanceAttempt[] = [];
+  private routeRejections: RouteRejection[] = [];
+
+  constructor(private readonly modelProfile: string = AUTO_MODEL_PROFILE) {}
+
+  /** Records the planner's rejections; codes only, never the provider-supplied messages. */
+  routed(routePlan: SharedPlannerRoutePlan): void {
+    this.routeRejections = routeRejectionsFrom(routePlan.rejectedProviders);
+  }
+
+  /** Records the rejections a routing failure carried out on its exception's details. */
+  routingFailed(details: Record<string, unknown> | undefined): void {
+    const rejected = details?.rejectedProviders;
+    if (Array.isArray(rejected)) {
+      this.routeRejections = routeRejectionsFrom(
+        rejected as SharedPlannerRoutePlan["rejectedProviders"]
+      );
+    }
+  }
+
+  /** Records how one provider attempt ended. */
+  attempted(
+    providerId: string,
+    outcome: ExecutionProvenanceAttempt["outcome"],
+    errorClass?: IndeRunErrorClass
+  ): void {
+    this.attempts.push({
+      providerId,
+      outcome,
+      ...(errorClass !== undefined ? { errorClass } : {})
+    });
+  }
+
+  /**
+   * 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 --
+   * and is absent when no provider was reached or every attempt failed before a commit.
+   */
+  build(attributedTo?: ProviderDescriptor, reportedModel?: string): ExecutionProvenance {
+    return {
+      schemaVersion: "1.0",
+      modelProfile: this.modelProfile,
+      ...(attributedTo !== undefined ? { providerId: attributedTo.id } : {}),
+      locality: attributedTo !== undefined ? localityOf(attributedTo) : "unknown",
+      ...(attributedTo?.model !== undefined ? { configuredModel: attributedTo.model } : {}),
+      ...(attributedTo !== undefined && reportedModel !== undefined ? { reportedModel } : {}),
+      attemptCount: this.attempts.length,
+      fallbackOccurred: this.attempts.length > 1,
+      attempts: [...this.attempts],
+      routeRejections: [...this.routeRejections]
+    };
+  }
+}
+
+function localityOf(descriptor: ProviderDescriptor): ExecutionProvenance["locality"] {
+  switch (descriptor.type) {
+    case "local":
+      return "on_device";
+    case "edge":
+      return "edge";
+    case "cloud":
+      return "cloud";
+  }
+}
+
+function routeRejectionsFrom(
+  rejected: SharedPlannerRoutePlan["rejectedProviders"]
+): RouteRejection[] {
+  return rejected.map((provider) => ({
+    providerId: provider.providerId,
+    codes: provider.reasons.map((reason) => reason.code)
+  }));
+}

package/src/core/provider.ts

@@ -19,6 +19,14 @@ export interface ProviderDescriptor {
    * Execution target type: 'local' (on-device), 'edge', or 'cloud'.
    */
   type: "local" | "edge" | "cloud";
+  /**
+   * The model this provider instance is bound to, when it can name one. A provider
+   * instance bound to one model is a *target* that model profiles list by `id`.
+   * 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.
+   */
+  model?: string;
   /**
    * Connection transport layer protocol.
    */
@@ -188,6 +196,11 @@ export type ProviderStreamEvent =
        */
       finishReason?: TaskResult["finishReason"];
       usage?: TaskResult["usage"];
+      /**
+       * The model identifier the provider's backend reported for this run, when it reports
+       * one. Carried into the terminal outcome's provenance; never inferred from configuration.
+       */
+      reportedModel?: string;
     }
   | { kind: "error"; error: unknown };
 

package/src/core/route-planner.ts

@@ -177,7 +177,8 @@ export function buildSharedPlannerInput(
   request: TaskRequest,
   snapshots: ProviderRuntimeSnapshot[],
   networkOnline: boolean,
-  interactionMode: InteractionMode = "run"
+  interactionMode: InteractionMode = "run",
+  modelProfile?: SharedPlannerInput["modelProfile"]
 ): SharedPlannerInput {
   const constraints = request.constraints ?? {};
   const preferences = request.preferences ?? {};
@@ -196,6 +197,7 @@ export function buildSharedPlannerInput(
     preferences: {
       optimizeFor: preferences.optimizeFor ?? "balanced"
     },
+    ...(modelProfile ? { modelProfile } : {}),
     providers: snapshots.map((snapshot) => ({
       descriptor: snapshot.descriptor,
       capabilities: snapshot.capabilities

package/src/core/router.ts

@@ -14,6 +14,7 @@ import {
   type InteractionMode,
   type ProviderRuntimeSnapshot,
   type RoutePlanner,
+  type SharedPlannerInput,
   type SharedPlannerRoutePlan,
   WasmRoutePlanner
 } from "./route-planner.js";
@@ -63,17 +64,25 @@ export class Router {
    *
    * The requested `interactionMode` is a planning input, not a post-filter: the
    * shared planner rejects providers that cannot satisfy it and says why, so the
-   * whole returned chain is mode-compatible.
+   * whole returned chain is mode-compatible. The resolved model profile is a
+   * planning input in the same way: the planner rejects targets outside it.
    */
   async selectRoute(
     request: TaskRequest,
     hostServices: HostServices,
-    interactionMode: InteractionMode = "run"
+    interactionMode: InteractionMode = "run",
+    modelProfile?: SharedPlannerInput["modelProfile"]
   ): Promise<RouteSelection> {
     const online = await hostServices.connectivity.isOnline();
     const snapshots = await collectProviderRuntimeSnapshots(this.registry.list(), hostServices);
 
-    const planInput = buildSharedPlannerInput(request, snapshots, online, interactionMode);
+    const planInput = buildSharedPlannerInput(
+      request,
+      snapshots,
+      online,
+      interactionMode,
+      modelProfile
+    );
     const outcome = await this.planner.planRoute(planInput);
 
     if (!outcome.routePlan) {