@abot-ai/runtime 1.0.0

package/dist/src/runtime/model/invoke-structured-step.js

@@ -0,0 +1,143 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { resolveRequestModelStepInvoker } from "./invoke-step.js";
+import { resolveOutputIncompleteError } from "./provider-completion.js";
+import { STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS, buildStructuredModelRepairHint, } from "./repair-prompts.js";
+/** Distinguishes repairable model output from provider/runtime failures. */
+export class StructuredModelInvalidOutputError extends Error {
+    modelStep;
+    validationStage;
+    issues;
+    repairAttempts;
+    repeatedInvalidOutput;
+    constructor(reason, modelStep, details) {
+        super(reason);
+        this.name = "StructuredModelInvalidOutputError";
+        this.modelStep = modelStep;
+        this.validationStage = details.validationStage;
+        this.issues = Object.freeze([...details.issues]);
+        this.repairAttempts = details.repairAttempts;
+        this.repeatedInvalidOutput = details.repeatedInvalidOutput;
+    }
+}
+export async function invokeStructuredModelStep(params) {
+    const modelStepInvoker = resolveRequestModelStepInvoker(params.request);
+    let messages = params.messages;
+    let previousRejectedOutput;
+    for (let repairAttempt = 0; repairAttempt <= STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS; repairAttempt += 1) {
+        const finalAttempt = repairAttempt === STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS;
+        const attempt = await modelStepInvoker.invoke({
+            modelStep: params.modelStep,
+            messages,
+            timeoutReason: params.timeoutReason,
+            format: params.format,
+            ...(params.contextCompaction
+                ? { contextCompaction: params.contextCompaction }
+                : {}),
+            accept(text, outputDiagnostics) {
+                const incompleteError = resolveOutputIncompleteError(outputDiagnostics);
+                if (incompleteError) {
+                    traceDebug("runtime.model", "step.output_incomplete", {
+                        requestId: params.request.requestId,
+                        modelStep: params.modelStep,
+                        issueCode: incompleteError.code,
+                        validationStage: incompleteError.stage,
+                        ...outputDiagnostics,
+                    });
+                    throw incompleteError;
+                }
+                const parsed = params.parse(text);
+                if (parsed.ok) {
+                    return Object.freeze({ ok: true, value: parsed.decision });
+                }
+                const repeatedInvalidOutput = previousRejectedOutput === text;
+                const diagnostic = {
+                    requestId: params.request.requestId,
+                    modelStep: params.modelStep,
+                    validationStage: parsed.stage,
+                    issues: projectIssues(parsed.issues),
+                    issueCount: parsed.issues.length,
+                    outputKind: classifyStructuredOutput(text),
+                    repairAttempt,
+                    maxRepairAttempts: STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS,
+                    repeatedInvalidOutput,
+                    ...outputDiagnostics,
+                };
+                traceDebug("runtime.model", "step.invalid_output", diagnostic);
+                const error = new StructuredModelInvalidOutputError(params.invalidOutputReason, params.modelStep, {
+                    validationStage: parsed.stage,
+                    issues: parsed.issues,
+                    repairAttempts: repairAttempt,
+                    repeatedInvalidOutput,
+                });
+                if (finalAttempt) {
+                    traceDebug("runtime.model", "step.repair.exhausted", diagnostic);
+                    throw error;
+                }
+                return Object.freeze({
+                    ok: false,
+                    error,
+                    rejectedOutput: text,
+                });
+            },
+        });
+        if (attempt.ok) {
+            if (repairAttempt > 0) {
+                traceDebug("runtime.model", "step.repair.succeeded", {
+                    requestId: params.request.requestId,
+                    modelStep: params.modelStep,
+                    repairAttempts: repairAttempt,
+                    maxRepairAttempts: STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS,
+                    sameRoleCall: true,
+                });
+            }
+            return attempt.value;
+        }
+        const repairHint = buildStructuredModelRepairHint({
+            repairAttempt: repairAttempt + 1,
+            stage: attempt.error.validationStage,
+            issues: attempt.error.issues,
+            repeatedInvalidOutput: attempt.error.repeatedInvalidOutput,
+        });
+        traceDebug("runtime.model", "step.repair.started", {
+            requestId: params.request.requestId,
+            modelStep: params.modelStep,
+            repairAttempt: repairAttempt + 1,
+            maxRepairAttempts: STRUCTURED_MODEL_MAX_REPAIR_ATTEMPTS,
+            validationStage: attempt.error.validationStage,
+            issues: projectIssues(attempt.error.issues),
+            issueCount: attempt.error.issues.length,
+            repairHintLength: repairHint.length,
+            repeatedInvalidOutput: attempt.error.repeatedInvalidOutput,
+            sameRoleCall: true,
+        });
+        previousRejectedOutput = attempt.rejectedOutput;
+        messages = [
+            ...params.messages,
+            Object.freeze({ role: "system", content: repairHint }),
+        ];
+    }
+    throw new Error("structured_model_repair_state_invalid");
+}
+function projectIssues(issues) {
+    return issues.map(({ code, path }) => Object.freeze({ code, path }));
+}
+function classifyStructuredOutput(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return "empty";
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(normalized);
+    }
+    catch {
+        return "non_json";
+    }
+    if (Array.isArray(decoded)) {
+        return "json_array";
+    }
+    if (decoded !== null && typeof decoded === "object") {
+        return "json_object";
+    }
+    return "json_scalar";
+}

package/dist/src/runtime/model/json-schema-value.d.ts

@@ -0,0 +1,9 @@
+export type JsonSchemaValueValidationIssue = Readonly<{
+    path: string;
+    message: string;
+}>;
+/**
+ * Post-validates the bounded, commonly used JSON Schema subset emitted to
+ * model providers. Unknown keywords remain provider-owned for compatibility.
+ */
+export declare function validateJsonSchemaValue(schema: Readonly<Record<string, unknown>>, value: unknown): JsonSchemaValueValidationIssue | undefined;

package/dist/src/runtime/model/json-schema-value.js

@@ -0,0 +1,261 @@
+const JSON_SCHEMA_VALIDATION_MAX_DEPTH = 32;
+const JSON_SCHEMA_VALIDATION_MAX_VISITS = 50_000;
+const JSON_SCHEMA_VALIDATION_MAX_ENUM_VALUES = 1_024;
+const JSON_SCHEMA_DIAGNOSTIC_PATH_MAX_LENGTH = 1_024;
+const JSON_SCHEMA_DIAGNOSTIC_SEGMENT_MAX_LENGTH = 128;
+/**
+ * Post-validates the bounded, commonly used JSON Schema subset emitted to
+ * model providers. Unknown keywords remain provider-owned for compatibility.
+ */
+export function validateJsonSchemaValue(schema, value) {
+    if (schema.type === "json_object") {
+        return isPlainRecord(value)
+            ? undefined
+            : issue("output", "The response must be one JSON object.");
+    }
+    const root = unwrapSchemaFormat(schema);
+    if (!root)
+        return undefined;
+    return validateNode(root, value, "output", 0, { visits: 0 });
+}
+function validateNode(schema, value, path, depth, state) {
+    state.visits += 1;
+    if (depth > JSON_SCHEMA_VALIDATION_MAX_DEPTH ||
+        state.visits > JSON_SCHEMA_VALIDATION_MAX_VISITS) {
+        return issue(path, "The JSON value is too complex to validate safely.");
+    }
+    if (Array.isArray(schema.enum)) {
+        if (schema.enum.length > JSON_SCHEMA_VALIDATION_MAX_ENUM_VALUES) {
+            return issue(path, "The declared enum is too large to validate safely.");
+        }
+        if (!schema.enum.some((candidate) => equalJsonValue(candidate, value))) {
+            return issue(path, "The value must match one declared enum value.");
+        }
+    }
+    if (Object.hasOwn(schema, "const") &&
+        !equalJsonValue(schema.const, value)) {
+        return issue(path, "The value must match the declared constant.");
+    }
+    const allOfIssue = validateAllOf(schema.allOf, value, path, depth, state);
+    if (allOfIssue)
+        return allOfIssue;
+    const anyOfIssue = validateAnyOf(schema.anyOf, value, path, depth, state);
+    if (anyOfIssue)
+        return anyOfIssue;
+    const oneOfIssue = validateOneOf(schema.oneOf, value, path, depth, state);
+    if (oneOfIssue)
+        return oneOfIssue;
+    if (!matchesDeclaredType(schema.type, value)) {
+        return issue(path, "The value has the wrong JSON type.");
+    }
+    if (typeof value === "string") {
+        const length = unicodeCodePointLength(value);
+        if (isNonNegativeInteger(schema.minLength) && length < schema.minLength) {
+            return issue(path, "The string is shorter than the declared minimum.");
+        }
+        if (isNonNegativeInteger(schema.maxLength) && length > schema.maxLength) {
+            return issue(path, "The string exceeds the declared maximum length.");
+        }
+        return undefined;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            return issue(path, "The number must be finite.");
+        }
+        if (schema.type === "integer" && !Number.isSafeInteger(value)) {
+            return issue(path, "The value must be an integer.");
+        }
+        if (typeof schema.minimum === "number" && value < schema.minimum) {
+            return issue(path, "The number is below the declared minimum.");
+        }
+        if (typeof schema.maximum === "number" && value > schema.maximum) {
+            return issue(path, "The number exceeds the declared maximum.");
+        }
+        if (typeof schema.exclusiveMinimum === "number" &&
+            value <= schema.exclusiveMinimum) {
+            return issue(path, "The number must exceed the declared lower bound.");
+        }
+        if (typeof schema.exclusiveMaximum === "number" &&
+            value >= schema.exclusiveMaximum) {
+            return issue(path, "The number must be below the declared upper bound.");
+        }
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        if (isNonNegativeInteger(schema.minItems) && value.length < schema.minItems) {
+            return issue(path, "The array has fewer items than required.");
+        }
+        if (isNonNegativeInteger(schema.maxItems) && value.length > schema.maxItems) {
+            return issue(path, "The array has more items than allowed.");
+        }
+        if (isPlainRecord(schema.items)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const itemIssue = validateNode(schema.items, value[index], appendPath(path, String(index)), depth + 1, state);
+                if (itemIssue)
+                    return itemIssue;
+            }
+        }
+        else if (Array.isArray(schema.items)) {
+            for (let index = 0; index < Math.min(value.length, schema.items.length); index += 1) {
+                const itemSchema = schema.items[index];
+                if (!isPlainRecord(itemSchema))
+                    continue;
+                const itemIssue = validateNode(itemSchema, value[index], appendPath(path, String(index)), depth + 1, state);
+                if (itemIssue)
+                    return itemIssue;
+            }
+        }
+        return undefined;
+    }
+    if (!isPlainRecord(value))
+        return undefined;
+    const properties = isPlainRecord(schema.properties)
+        ? schema.properties
+        : undefined;
+    if (Array.isArray(schema.required)) {
+        for (const property of schema.required) {
+            if (typeof property !== "string")
+                continue;
+            if (!Object.hasOwn(value, property)) {
+                return issue(appendPath(path, property), "A required property is missing.");
+            }
+        }
+    }
+    if (properties) {
+        for (const [property, propertySchema] of Object.entries(properties)) {
+            if (!Object.hasOwn(value, property) || !isPlainRecord(propertySchema)) {
+                continue;
+            }
+            const propertyIssue = validateNode(propertySchema, value[property], appendPath(path, property), depth + 1, state);
+            if (propertyIssue)
+                return propertyIssue;
+        }
+    }
+    for (const [property, propertyValue] of Object.entries(value)) {
+        if (properties && Object.hasOwn(properties, property))
+            continue;
+        if (schema.additionalProperties === false) {
+            return issue(path, "The property is not declared by the response format.");
+        }
+        if (isPlainRecord(schema.additionalProperties)) {
+            const additionalIssue = validateNode(schema.additionalProperties, propertyValue, path, depth + 1, state);
+            if (additionalIssue)
+                return additionalIssue;
+        }
+    }
+    return undefined;
+}
+function validateAllOf(input, value, path, depth, state) {
+    if (!Array.isArray(input))
+        return undefined;
+    for (const schema of input) {
+        if (!isPlainRecord(schema))
+            continue;
+        const branchIssue = validateNode(schema, value, path, depth + 1, state);
+        if (branchIssue)
+            return branchIssue;
+    }
+    return undefined;
+}
+function validateAnyOf(input, value, path, depth, state) {
+    if (!Array.isArray(input))
+        return undefined;
+    const branches = input.filter(isPlainRecord);
+    if (branches.length === 0)
+        return undefined;
+    for (const schema of branches) {
+        if (!validateNode(schema, value, path, depth + 1, state))
+            return undefined;
+    }
+    return issue(path, "The value must match at least one allowed schema.");
+}
+function validateOneOf(input, value, path, depth, state) {
+    if (!Array.isArray(input))
+        return undefined;
+    const branches = input.filter(isPlainRecord);
+    if (branches.length === 0)
+        return undefined;
+    let matches = 0;
+    for (const schema of branches) {
+        if (!validateNode(schema, value, path, depth + 1, state))
+            matches += 1;
+    }
+    return matches === 1
+        ? undefined
+        : issue(path, "The value must match exactly one allowed schema.");
+}
+function matchesDeclaredType(type, value) {
+    if (typeof type === "string")
+        return matchesType(type, value);
+    if (Array.isArray(type)) {
+        const declared = type.filter((entry) => typeof entry === "string");
+        return declared.length === 0 || declared.some((entry) => matchesType(entry, value));
+    }
+    return true;
+}
+function matchesType(type, value) {
+    switch (type) {
+        case "object":
+            return isPlainRecord(value);
+        case "array":
+            return Array.isArray(value);
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return typeof value === "number" && Number.isSafeInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "null":
+            return value === null;
+        default:
+            return true;
+    }
+}
+function unwrapSchemaFormat(input) {
+    if (input.type === "json_schema" && isPlainRecord(input.schema)) {
+        return input.schema;
+    }
+    return input;
+}
+function equalJsonValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return (left.length === right.length &&
+            left.every((value, index) => equalJsonValue(value, right[index])));
+    }
+    if (!isPlainRecord(left) || !isPlainRecord(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return (leftKeys.length === rightKeys.length &&
+        leftKeys.every((key) => Object.hasOwn(right, key) && equalJsonValue(left[key], right[key])));
+}
+function appendPath(path, segment) {
+    const boundedSegment = segment
+        .slice(0, JSON_SCHEMA_DIAGNOSTIC_SEGMENT_MAX_LENGTH)
+        .replace(/~/gu, "~0")
+        .replace(/\//gu, "~1");
+    return `${path}/${boundedSegment}`.slice(0, JSON_SCHEMA_DIAGNOSTIC_PATH_MAX_LENGTH);
+}
+function issue(path, message) {
+    return Object.freeze({ path, message });
+}
+function isNonNegativeInteger(input) {
+    return Number.isSafeInteger(input) && input >= 0;
+}
+function unicodeCodePointLength(input) {
+    let length = 0;
+    for (const _character of input)
+        length += 1;
+    return length;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/src/runtime/model/model-catalog.d.ts

@@ -0,0 +1,18 @@
+import type { ModelGatewayPolicyConfig, ModelGatewayProfileCapabilities } from "../../model-gateway/types.js";
+import type { RuntimeConfig } from "../ports.js";
+export type RuntimeModelCatalogProfile = {
+    id: string;
+    label: string;
+    providerId: string;
+    provider: string;
+    model: string;
+    supportsThinking: boolean;
+    capabilities: ModelGatewayProfileCapabilities;
+    supportsImageInput: boolean;
+};
+export type RuntimeModelCatalog = {
+    defaultProfileId: string;
+    profiles: RuntimeModelCatalogProfile[];
+};
+export declare function projectRuntimeModelCatalog(modelPolicy: ModelGatewayPolicyConfig | undefined): RuntimeModelCatalog;
+export declare function loadRuntimeModelCatalog(config: RuntimeConfig): RuntimeModelCatalog;

package/dist/src/runtime/model/model-catalog.js

@@ -0,0 +1,55 @@
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { loadRequestRunnerConfig } from "../config/runner/loader.js";
+import { createRequestModelPolicy } from "../config/runner/model-policy.js";
+import { resolvedModelStepSupportsImageAttachments } from "./model-step-capability-policy.js";
+export function projectRuntimeModelCatalog(modelPolicy) {
+    const providers = modelPolicy?.providers ?? {};
+    const configuredProfiles = modelPolicy?.profiles ?? {};
+    const defaultProfileId = modelPolicy?.defaults?.profileId?.trim();
+    if (!defaultProfileId) {
+        throw new Error("Invalid runtime model catalog: models.defaults.profileId must be configured");
+    }
+    if (!configuredProfiles[defaultProfileId]) {
+        throw new Error(`Invalid runtime model catalog: models.defaults.profileId references unknown model profile ${defaultProfileId}`);
+    }
+    const profiles = Object.entries(configuredProfiles).map(([id, profile]) => {
+        const providerId = profile.provider?.trim();
+        if (!providerId) {
+            throw new Error(`Invalid runtime model catalog: models.profiles.${id}.provider must be configured`);
+        }
+        const providerConfig = providers[providerId];
+        if (!providerConfig) {
+            throw new Error(`Invalid runtime model catalog: models.profiles.${id}.provider references unknown provider ${providerId}`);
+        }
+        return {
+            id,
+            label: profile.label?.trim() || id,
+            providerId,
+            provider: providerConfig.type,
+            model: profile.model,
+            supportsThinking: profile.supportsThinking === true,
+            capabilities: profile.capabilities ?? {
+                inputModalities: ["text"],
+                outputModalities: ["text"],
+            },
+            supportsImageInput: resolvedModelStepSupportsImageAttachments({
+                modelStep: MODEL_STEPS.SUPERVISOR_DECISION,
+                modelPolicy,
+                modelPreference: { profileId: id },
+            }),
+        };
+    });
+    return {
+        defaultProfileId,
+        profiles,
+    };
+}
+export function loadRuntimeModelCatalog(config) {
+    const runnerConfig = loadRequestRunnerConfig({
+        configPath: config.requestRunner.configPath,
+    });
+    return projectRuntimeModelCatalog(createRequestModelPolicy({
+        platformPolicy: config.models,
+        runnerConfig,
+    }));
+}

package/dist/src/runtime/model/model-context-budget.d.ts

@@ -0,0 +1,25 @@
+import type { ModelGatewayFormat, ModelGatewayPolicyConfig, ModelPreference, ResolvedModelInvocation } from "../../model-gateway/types.js";
+import type { AgentMode } from "../../shared/types.js";
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { RequestRunnerConfig } from "../config/runner/contracts.js";
+import type { RequestContextBudget } from "../context/request-context-contracts.js";
+export declare function resolveModelContextBudget(params: {
+    runnerConfig: RequestRunnerConfig;
+    agentMode: AgentMode;
+    modelStep: ModelStep;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+}): RequestContextBudget;
+export type ResolvedModelContextAdmission = Readonly<{
+    invocation: ResolvedModelInvocation;
+    budget: RequestContextBudget;
+    effectiveFormat?: ModelGatewayFormat;
+}>;
+export declare function resolveModelContextAdmission(params: {
+    runnerConfig: RequestRunnerConfig;
+    agentMode: AgentMode;
+    modelStep: ModelStep;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    requestFormat?: ModelGatewayFormat;
+}): ResolvedModelContextAdmission;

package/dist/src/runtime/model/model-context-budget.js

@@ -0,0 +1,51 @@
+import { resolveModelInvocation } from "../../model-gateway/invocation-policy.js";
+import { estimateConfiguredStepInstructionReserveTokens } from "../config/runner/step-instructions.js";
+export function resolveModelContextBudget(params) {
+    const admission = resolveModelContextAdmission(params);
+    const configuredInstructionReserveTokens = estimateConfiguredStepInstructionReserveTokens({
+        runnerConfig: params.runnerConfig,
+        modelStep: params.modelStep,
+        ...(admission.budget.tokenEstimation
+            ? { tokenEstimation: admission.budget.tokenEstimation }
+            : {}),
+    });
+    return configuredInstructionReserveTokens > 0
+        ? Object.freeze({
+            ...admission.budget,
+            configuredInstructionReserveTokens,
+        })
+        : admission.budget;
+}
+export function resolveModelContextAdmission(params) {
+    const invocation = resolveModelInvocation({
+        agentMode: params.agentMode,
+        modelStep: params.modelStep,
+        ...(params.modelPreference
+            ? { modelPreference: params.modelPreference }
+            : {}),
+        ...(params.modelPolicy ? { modelPolicy: params.modelPolicy } : {}),
+    });
+    const formatTokenAccounting = invocation.profile.context.formatTokenAccounting;
+    const budget = Object.freeze({
+        contextWindowTokens: invocation.profile.contextWindowTokens,
+        outputReserveTokens: params.runnerConfig.context.outputReserveTokens,
+        safetyReserveTokens: params.runnerConfig.context.safetyReserveTokens,
+        attachmentReserveTokens: params.runnerConfig.context.attachmentReserveTokens,
+        formatTokenAccounting: {
+            mode: formatTokenAccounting?.mode ?? "estimate",
+            ...(formatTokenAccounting?.fixedOverheadTokens !== undefined
+                ? { fixedOverheadTokens: formatTokenAccounting.fixedOverheadTokens }
+                : {}),
+        },
+        ...(invocation.profile.context.tokenEstimation
+            ? { tokenEstimation: invocation.profile.context.tokenEstimation }
+            : {}),
+    });
+    return Object.freeze({
+        invocation,
+        budget,
+        ...((params.requestFormat ?? invocation.format)
+            ? { effectiveFormat: params.requestFormat ?? invocation.format }
+            : {}),
+    });
+}

package/dist/src/runtime/model/model-selection.d.ts

@@ -0,0 +1,16 @@
+import type { ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
+import type { AgentMode } from "../../shared/types.js";
+import { type RequestExecutionPolicySelection, type RuntimeModelExecutionPolicies } from "../config/model-execution-policy.js";
+type ModelSelection = {
+    agentMode: AgentMode;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    execution: RequestExecutionPolicySelection;
+};
+export declare function resolveModelSelection(params: {
+    agentMode: unknown;
+    modelPreference: unknown;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelExecutionPolicies?: RuntimeModelExecutionPolicies;
+}): ModelSelection;
+export {};

package/dist/src/runtime/model/model-selection.js

@@ -0,0 +1,66 @@
+import { resolveAgentMode } from "../../shared/agent.js";
+import { resolveProfileCandidate } from "../../shared/invocation-profile-selection.js";
+import { DEFAULT_REQUEST_EXECUTION_POLICY_ID, } from "../config/model-execution-policy.js";
+function normalizeModelPreference(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const profileId = value.profileId;
+    if (typeof profileId !== "string" || profileId.trim().length === 0) {
+        return undefined;
+    }
+    const scope = value.scope;
+    return {
+        profileId: profileId.trim(),
+        scope: scope === "main" ? "main" : "all",
+    };
+}
+function resolveConfiguredProfile(profileId, policy) {
+    return policy?.profiles?.[profileId];
+}
+/**
+ * Resolves process policy from the request's canonical base profile. This is
+ * intentionally independent of modelStep: step calibration happens inside an
+ * already-selected request process, and both preference scopes include the
+ * root invocation.
+ */
+function resolveRequestExecutionPolicy(params) {
+    const preferred = resolveProfileCandidate({
+        profileId: params.modelPreference?.profileId,
+        policy: params.modelPolicy,
+        source: "clientPreference",
+        resolveProfile: resolveConfiguredProfile,
+    });
+    const configured = resolveProfileCandidate({
+        profileId: params.modelPolicy?.defaults?.profileId,
+        policy: params.modelPolicy,
+        source: "default",
+        resolveProfile: resolveConfiguredProfile,
+    });
+    const primary = params.modelPolicy?.defaults?.overrideClientPreference === true
+        ? (configured ?? preferred)
+        : (preferred ?? configured);
+    const configuredExecution = primary
+        ? params.modelExecutionPolicies?.[primary.profileId]
+        : undefined;
+    return Object.freeze({
+        policy: configuredExecution?.policy ?? DEFAULT_REQUEST_EXECUTION_POLICY_ID,
+        ...(primary ? { primaryProfileId: primary.profileId } : {}),
+        source: configuredExecution ? "model_profile" : "default",
+    });
+}
+export function resolveModelSelection(params) {
+    const modelPreference = normalizeModelPreference(params.modelPreference);
+    return {
+        agentMode: resolveAgentMode(params.agentMode),
+        ...(modelPreference ? { modelPreference } : {}),
+        ...(params.modelPolicy ? { modelPolicy: params.modelPolicy } : {}),
+        execution: resolveRequestExecutionPolicy({
+            ...(modelPreference ? { modelPreference } : {}),
+            ...(params.modelPolicy ? { modelPolicy: params.modelPolicy } : {}),
+            ...(params.modelExecutionPolicies
+                ? { modelExecutionPolicies: params.modelExecutionPolicies }
+                : {}),
+        }),
+    };
+}

package/dist/src/runtime/model/model-step-capability-policy.d.ts

@@ -0,0 +1,14 @@
+import type { ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
+import type { ModelStep } from "../../shared/types.js";
+export declare function resolvedModelStepImageAttachmentProfileId(params: {
+    taskType?: string;
+    modelStep: ModelStep | string;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelPreference?: ModelPreference;
+}): string | undefined;
+export declare function resolvedModelStepSupportsImageAttachments(params: {
+    taskType?: string;
+    modelStep: ModelStep | string;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelPreference?: ModelPreference;
+}): boolean;