@dcdr/contracts 1.9.6

package/dist/intent.contract.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentType = void 0;
+/**
+ * Supported intent execution types.
+ *
+ * This defines the type of task the intent performs and which
+ * provider capabilities are required.
+ */
+var IntentType;
+(function (IntentType) {
+    /**
+     * Standard conversational or prompt-response interaction.
+     *
+     * Examples:
+     * - Q&A
+     * - summarization
+     * - reasoning
+     * - structured output generation
+     */
+    IntentType["CHAT"] = "CHAT";
+    /**
+     * Text embedding generation.
+     *
+     * Examples:
+     * - semantic search
+     * - vector indexing
+     * - similarity comparison
+     */
+    IntentType["EMBEDDING"] = "EMBEDDING";
+    /**
+     * Image generation.
+     *
+     * Examples:
+     * - DALL·E
+     * - diffusion models
+     */
+    IntentType["IMAGE_GENERATION"] = "IMAGE_GENERATION";
+    /**
+     * Image understanding / multimodal analysis.
+     *
+     * Examples:
+     * - vision LLMs
+     * - OCR-assisted models
+     */
+    IntentType["IMAGE_ANALYSIS"] = "IMAGE_ANALYSIS";
+    /**
+     * Audio transcription.
+     *
+     * Examples:
+     * - Whisper
+     * - speech-to-text models
+     */
+    IntentType["SPEECH_TO_TEXT"] = "SPEECH_TO_TEXT";
+    /**
+     * Audio generation / text-to-speech.
+     */
+    IntentType["TEXT_TO_SPEECH"] = "TEXT_TO_SPEECH";
+    /**
+     * Multimodal tasks combining text + images + audio.
+     */
+    IntentType["MULTIMODAL"] = "MULTIMODAL";
+    /**
+     * Deterministic tool execution.
+     *
+     * Examples:
+     * - HTTP calls
+     * - scripts
+     * - external API connectors
+     */
+    IntentType["TOOL"] = "TOOL";
+    /**
+     * Internal deterministic rule engine.
+     */
+    IntentType["RULE_ENGINE"] = "RULE_ENGINE";
+})(IntentType || (exports.IntentType = IntentType = {}));

package/dist/logs.contract.d.ts

@@ -0,0 +1,10 @@
+import { ExecutionError } from "./errors.contract";
+import { ExecutionReport, ExecutionStatus } from "./execution.contract";
+import { Message } from "./messages.contract";
+export type ExecutionLogEvent = ExecutionReport & {
+    status: ExecutionStatus;
+    input?: Message[];
+    output?: unknown;
+    error?: ExecutionError;
+};
+//# sourceMappingURL=logs.contract.d.ts.map

package/dist/logs.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.contract.d.ts","sourceRoot":"","sources":["../src/logs.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAoB,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAI9C,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG;IAChD,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,CAAC"}

package/dist/logs.contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/messages.contract.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Supported message roles for chat-style prompts.
+ * Keep this provider-agnostic; each provider adapter will map it as needed.
+ */
+export type MessageRole = "system" | "user";
+/**
+ * A single prompt message in a provider-agnostic format.
+ * - `content` can include `${placeholders}` to be rendered by the gateway.
+ * - `name` is optional and mainly used for tool messages or multi-agent style.
+ */
+export interface Message {
+    role: MessageRole;
+    content: string;
+    name?: string;
+}
+//# sourceMappingURL=messages.contract.d.ts.map

package/dist/messages.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.contract.d.ts","sourceRoot":"","sources":["../src/messages.contract.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAE;AAE7C;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/messages.contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/policies.contract.d.ts

@@ -0,0 +1,253 @@
+import { IntentProvider } from "./provider.contract";
+/**
+ * Retry policy for an intent/model.
+ * Keep this stable; it's part of the behavior contract.
+ */
+/**
+ * Retry policy for an intent/model.
+ * Keep this stable; it's part of the behavior contract.
+ */
+export declare class RetryPolicy {
+    /**
+     * Max total attempts across all candidates (including first try).
+     * Example: 3 => try primary + up to 2 more attempts.
+     */
+    maxAttempts: number;
+    /**
+     * Max retries per single candidate before switching to next.
+     * Example: 1 => at most 1 attempt per candidate (no local retries).
+     * Example: 2 => 2 attempts on same candidate before fallback.
+     */
+    maxPerCandidate?: number;
+    /**
+     * Timeout for a single provider attempt in milliseconds.
+     * If not provided, provider adapter default is used.
+     */
+    attemptTimeoutMs?: number;
+    /**
+     * Whether fallback to the next candidate is allowed.
+     * If false, fail after exhausting retries of the selected candidate(s).
+     */
+    allowFallback: boolean;
+    /**
+        * Whether to do a "repair pass" when output fails JSON/schema validation.
+        * Useful for strict JSON intents (format parser, mappers).
+        *
+        * Repair pass semantics (runtime behavior)
+        * - Trigger condition: the previous attempt failed with `PARSE_FAIL` or `SCHEMA_FAIL`.
+        * - Structured-only: only applies when the intent is in structured mode (has `outputSchema` and/or
+        *   `response_format` is `json_object`/`json_schema`).
+        * - Effect: the gateway appends one extra *system* instruction message to the existing rendered prompt
+        *   (marker: `[DCDR_REPAIR_PASS]`) asking the model to re-emit ONLY valid JSON matching the expected schema.
+        * - Budgeting: consumes the normal retry budget (must still be within `maxPerCandidate` and `maxAttempts`).
+        * - Scope: at most one repair pass is attempted per candidate execution.
+        *
+        * Notes
+        * - This does not change the intent inputs; it only changes the instruction for the next attempt.
+        * - If you want repair behavior, you typically enable this AND include `PARSE_FAIL`/`SCHEMA_FAIL` in `retryOn`,
+        *   but the repair pass itself is allowed even when `retryOn` is empty.
+     */
+    repairOnParseFail?: boolean;
+    /**
+     * Backoff strategy between attempts.
+     * - fixed: always wait retryBackoffMs
+     * - exponential: retryBackoffMs * 2^(n-1), capped by retryBackoffCapMs
+     */
+    retryBackoffStrategy?: "fixed" | "exponential";
+    /**
+     * Base backoff delay in milliseconds between attempts (after the first).
+     * Defaults can be applied by the engine if undefined.
+     */
+    retryBackoffMs?: number;
+    /**
+     * Maximum backoff delay in milliseconds when using exponential strategy.
+     */
+    retryBackoffCapMs?: number;
+    /**
+     * Adds random jitter [0..retryJitterMs] to backoff to avoid synchronized retries.
+     */
+    retryJitterMs?: number;
+    /**
+     * Error codes that are considered retryable/fallbackable.
+     * Keep values stable. Your engine should map real exceptions into these codes.
+     */
+    retryOn?: Array<"TIMEOUT" | "RATE_LIMIT" | "UPSTREAM_5XX" | "NETWORK" | "PARSE_FAIL" | "SCHEMA_FAIL">;
+}
+export type ResponseFormat = "json_object" | "json_schema" | "text" | "markdown" | "html";
+export declare class PromptParameters {
+    /**
+     * Typical range: 0.0–2.0 (default: 0.7)
+     */
+    temperature?: number;
+    /**
+     * Typical range: 0.0–1.0 (default: 1)
+     */
+    top_p?: number;
+    /**
+     * Typical range: 1–100 (default: 50)
+     */
+    top_k?: number;
+    /**
+     * Typical range: 1–4096 (default: 2048)
+     */
+    max_tokens?: number;
+    /**
+     * Any integer (optional, for reproducibility)
+     */
+    seed?: number;
+    enable_thinking?: boolean;
+    response_format?: ResponseFormat;
+    /**
+     * Typical range: -2.0–2.0 (default: 0.0)
+     */
+    presence_penalty?: number;
+    /**
+     * Typical range: -2.0–2.0 (default: 0.0)
+     */
+    frequency_penalty?: number;
+}
+/**
+ * Supported execution policy types.
+ *
+ * These policies decide how the gateway chooses the initial implementation
+ * order before retries / fallback logic is applied.
+ *
+ * Notes:
+ * - RetryPolicy is still responsible for retry attempts and failure handling.
+ * - ExecutionPolicy is responsible for candidate planning and prioritization.
+ */
+export declare enum ExecutionPolicyType {
+    /**
+     * Use implementation weights as provided.
+     * This is the simplest and most backward-compatible mode.
+     */
+    WEIGHTED = "WEIGHTED",
+    /**
+     * Use a fixed implementation order.
+     * The first active/healthy implementation is tried first, then the next one.
+     */
+    FALLBACK_CHAIN = "FALLBACK_CHAIN",
+    /**
+     * Prefer local / office / on-prem implementations first.
+     * If none are available, use the remaining implementations.
+     */
+    LOCAL_FIRST = "LOCAL_FIRST",
+    /**
+     * Prefer the cheapest implementations first.
+     * Requires each implementation to expose an estimated cost score.
+     */
+    CHEAPEST_FIRST = "CHEAPEST_FIRST",
+    /**
+     * Prefer the fastest implementations first.
+     * Requires each implementation to expose an expected latency score.
+     */
+    FASTEST_FIRST = "FASTEST_FIRST",
+    /**
+     * Prefer the highest-quality implementations first.
+     * Requires each implementation to expose a quality score.
+     */
+    QUALITY_FIRST = "QUALITY_FIRST"
+}
+/**
+ * Optional behavior when the selected policy cannot be fully evaluated.
+ *
+ * Example:
+ * - CHEAPEST_FIRST was requested, but implementations do not provide cost metadata.
+ */
+export declare enum ExecutionPolicyFallbackMode {
+    /**
+     * Fall back to simple weighted selection.
+     */
+    WEIGHTED = "WEIGHTED",
+    /**
+     * Fall back to the declared implementation order.
+     */
+    DECLARED_ORDER = "DECLARED_ORDER",
+    /**
+     * Fail fast if the policy cannot be evaluated correctly.
+     */
+    ERROR = "ERROR"
+}
+/**
+ * Exploration modes for candidate planning.
+ *
+ * Exploration is always explicit (opt-in) and is applied *after* deterministic ordering.
+ *
+ * V1 invariant
+ * - Do not combine weight-based selection with score-based ordering.
+ * - Exploration may reorder which candidate is tried first, but it must not change the underlying score ordering.
+ */
+export declare enum ExplorationMode {
+    /**
+     * Epsilon-greedy exploration over the top-K candidates.
+     *
+     * With probability `epsilon`, pick a random candidate in the top-K list.
+     * Otherwise, keep the deterministic best candidate.
+     */
+    EPSILON_GREEDY_TOP_K = "EPSILON_GREEDY_TOP_K"
+}
+/**
+ * Optional exploration configuration.
+ *
+ * Notes
+ * - This is intended for Cloud/Cloud Pro only; runtime (self-hosted) may reject registries that require it.
+ * - Parameters are validated at runtime.
+ */
+export interface ExplorationPolicy {
+    /** Exploration mode. */
+    mode: ExplorationMode;
+    /** Probability of exploring (0..1). */
+    epsilon: number;
+    /** Max number of top candidates to sample within (>= 1). */
+    topK: number;
+}
+/**
+ * A simple execution policy contract for v1.
+ *
+ * This policy defines how the gateway should prioritize candidate
+ * implementations for an intent before executing retries/fallbacks.
+ *
+ * Design goals:
+ * - Simple
+ * - Backward-compatible
+ * - Easy to store in DB
+ * - Easy to render in UI
+ */
+export interface ExecutionPolicy {
+    /** Policy type. */
+    type: ExecutionPolicyType;
+    /**
+     * Optional fixed implementation order.
+     *
+     * Used mainly for:
+     * - FALLBACK_CHAIN
+     *
+     * Values should contain ImplementationContract IDs.
+     */
+    implementationOrder?: string[];
+    /**
+     * Optional provider affinity ordering.
+     *
+     * Used mainly for:
+     * - LOCAL_FIRST
+     *
+     * Example:
+     * [OFFICE, OPEN_AI]
+     */
+    preferredProviders?: IntentProvider[];
+    /**
+     * Secondary fallback mode if the selected policy cannot be fully evaluated.
+     *
+     * Example:
+     * - CHEAPEST_FIRST without cost metadata
+     * - FASTEST_FIRST without latency metadata
+     */
+    fallbackMode?: ExecutionPolicyFallbackMode;
+    /**
+     * Optional exploration behavior applied after deterministic ordering.
+     *
+     * Exploration is never enabled by default; it is only used when this block is present.
+     */
+    exploration?: ExplorationPolicy;
+}
+//# sourceMappingURL=policies.contract.d.ts.map

package/dist/policies.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.contract.d.ts","sourceRoot":"","sources":["../src/policies.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD;;;GAGG;AACH;;;GAGG;AACH,qBAAa,WAAW;IACpB;;;OAGG;IAGH,WAAW,EAAE,MAAM,CAAK;IAExB;;;;OAIG;IAIH,eAAe,CAAC,EAAE,MAAM,CAAK;IAE7B;;;OAGG;IAGH,gBAAgB,CAAC,EAAE,MAAM,CAAS;IAElC;;;OAGG;IAEH,aAAa,EAAE,OAAO,CAAQ;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IAGH,iBAAiB,CAAC,EAAE,OAAO,CAAS;IAGpC;;;;OAIG;IAEH,oBAAoB,CAAC,EAAE,OAAO,GAAG,aAAa,CAAiB;IAE/D;;;OAGG;IAIH,cAAc,CAAC,EAAE,MAAM,CAAO;IAE9B;;OAEG;IAIH,iBAAiB,CAAC,EAAE,MAAM,CAAQ;IAElC;;OAEG;IAIH,aAAa,CAAC,EAAE,MAAM,CAAO;IAG7B;;;OAGG;IAEH,OAAO,CAAC,EAAE,KAAK,CACT,SAAS,GACT,YAAY,GACZ,cAAc,GACd,SAAS,GACT,YAAY,GACZ,aAAa,CAClB,CAAC;CACL;AAID,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,aAAa,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;AAG1F,qBAAa,gBAAgB;IACzB;;OAEG;IAIH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IAIH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IAIH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IAIH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IAEH,IAAI,CAAC,EAAE,MAAM,CAAC;IAId,eAAe,CAAC,EAAE,OAAO,CAAC;IAG1B,eAAe,CAAC,EAAE,cAAc,CAAA;IAEhC;;OAEG;IAIH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;OAEG;IAIH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAMD;;;;;;;;;GASG;AACH,oBAAY,mBAAmB;IAC3B;;;OAGG;IACH,QAAQ,aAAa;IAErB;;;OAGG;IACH,cAAc,mBAAmB;IAEjC;;;OAGG;IACH,WAAW,gBAAgB;IAE3B;;;OAGG;IACH,cAAc,mBAAmB;IAEjC;;;OAGG;IACH,aAAa,kBAAkB;IAE/B;;;OAGG;IACH,aAAa,kBAAkB;CAClC;AAED;;;;;GAKG;AACH,oBAAY,2BAA2B;IACnC;;OAEG;IACH,QAAQ,aAAa;IAErB;;OAEG;IACH,cAAc,mBAAmB;IAEjC;;OAEG;IACH,KAAK,UAAU;CAClB;AAED;;;;;;;;GAQG;AACH,oBAAY,eAAe;IACvB;;;;;OAKG;IACH,oBAAoB,yBAAyB;CAChD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAC9B,wBAAwB;IACxB,IAAI,EAAE,eAAe,CAAC;IAEtB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAEhB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CAChB;AAID;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAG5B,mBAAmB;IACnB,IAAI,EAAE,mBAAmB,CAAC;IAE1B;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE/B;;;;;;;;OAQG;IACH,kBAAkB,CAAC,EAAE,cAAc,EAAE,CAAC;IAEtC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,2BAA2B,CAAC;IAE3C;;;;OAIG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACnC"}

package/dist/policies.contract.js

@@ -0,0 +1,283 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorationMode = exports.ExecutionPolicyFallbackMode = exports.ExecutionPolicyType = exports.PromptParameters = exports.RetryPolicy = void 0;
+const class_validator_1 = require("class-validator");
+/**
+ * Retry policy for an intent/model.
+ * Keep this stable; it's part of the behavior contract.
+ */
+/**
+ * Retry policy for an intent/model.
+ * Keep this stable; it's part of the behavior contract.
+ */
+class RetryPolicy {
+    /**
+     * Max total attempts across all candidates (including first try).
+     * Example: 3 => try primary + up to 2 more attempts.
+     */
+    maxAttempts = 1;
+    /**
+     * Max retries per single candidate before switching to next.
+     * Example: 1 => at most 1 attempt per candidate (no local retries).
+     * Example: 2 => 2 attempts on same candidate before fallback.
+     */
+    maxPerCandidate = 1;
+    /**
+     * Timeout for a single provider attempt in milliseconds.
+     * If not provided, provider adapter default is used.
+     */
+    attemptTimeoutMs = 60000; // Default to 60 seconds
+    /**
+     * Whether fallback to the next candidate is allowed.
+     * If false, fail after exhausting retries of the selected candidate(s).
+     */
+    allowFallback = true;
+    /**
+        * Whether to do a "repair pass" when output fails JSON/schema validation.
+        * Useful for strict JSON intents (format parser, mappers).
+        *
+        * Repair pass semantics (runtime behavior)
+        * - Trigger condition: the previous attempt failed with `PARSE_FAIL` or `SCHEMA_FAIL`.
+        * - Structured-only: only applies when the intent is in structured mode (has `outputSchema` and/or
+        *   `response_format` is `json_object`/`json_schema`).
+        * - Effect: the gateway appends one extra *system* instruction message to the existing rendered prompt
+        *   (marker: `[DCDR_REPAIR_PASS]`) asking the model to re-emit ONLY valid JSON matching the expected schema.
+        * - Budgeting: consumes the normal retry budget (must still be within `maxPerCandidate` and `maxAttempts`).
+        * - Scope: at most one repair pass is attempted per candidate execution.
+        *
+        * Notes
+        * - This does not change the intent inputs; it only changes the instruction for the next attempt.
+        * - If you want repair behavior, you typically enable this AND include `PARSE_FAIL`/`SCHEMA_FAIL` in `retryOn`,
+        *   but the repair pass itself is allowed even when `retryOn` is empty.
+     */
+    repairOnParseFail = false;
+    /**
+     * Backoff strategy between attempts.
+     * - fixed: always wait retryBackoffMs
+     * - exponential: retryBackoffMs * 2^(n-1), capped by retryBackoffCapMs
+     */
+    retryBackoffStrategy = "exponential";
+    /**
+     * Base backoff delay in milliseconds between attempts (after the first).
+     * Defaults can be applied by the engine if undefined.
+     */
+    retryBackoffMs = 250;
+    /**
+     * Maximum backoff delay in milliseconds when using exponential strategy.
+     */
+    retryBackoffCapMs = 5000;
+    /**
+     * Adds random jitter [0..retryJitterMs] to backoff to avoid synchronized retries.
+     */
+    retryJitterMs = 250;
+    /**
+     * Error codes that are considered retryable/fallbackable.
+     * Keep values stable. Your engine should map real exceptions into these codes.
+     */
+    retryOn;
+}
+exports.RetryPolicy = RetryPolicy;
+__decorate([
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(10)
+], RetryPolicy.prototype, "maxAttempts", void 0);
+__decorate([
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(10),
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "maxPerCandidate", void 0);
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(600000) // 10 minutes max timeout
+], RetryPolicy.prototype, "attemptTimeoutMs", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)()
+], RetryPolicy.prototype, "allowFallback", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)()
+], RetryPolicy.prototype, "repairOnParseFail", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "retryBackoffStrategy", void 0);
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(600000),
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "retryBackoffMs", void 0);
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(600000),
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "retryBackoffCapMs", void 0);
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(600000),
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "retryJitterMs", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)()
+], RetryPolicy.prototype, "retryOn", void 0);
+class PromptParameters {
+    /**
+     * Typical range: 0.0–2.0 (default: 0.7)
+     */
+    temperature;
+    /**
+     * Typical range: 0.0–1.0 (default: 1)
+     */
+    top_p;
+    /**
+     * Typical range: 1–100 (default: 50)
+     */
+    top_k;
+    /**
+     * Typical range: 1–4096 (default: 2048)
+     */
+    max_tokens;
+    /**
+     * Any integer (optional, for reproducibility)
+     */
+    seed;
+    enable_thinking;
+    response_format;
+    /**
+     * Typical range: -2.0–2.0 (default: 0.0)
+     */
+    presence_penalty;
+    /**
+     * Typical range: -2.0–2.0 (default: 0.0)
+     */
+    frequency_penalty;
+}
+exports.PromptParameters = PromptParameters;
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(2),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "temperature", void 0);
+__decorate([
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(1),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "top_p", void 0);
+__decorate([
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "top_k", void 0);
+__decorate([
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(8192),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "max_tokens", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "seed", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)()
+], PromptParameters.prototype, "enable_thinking", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "response_format", void 0);
+__decorate([
+    (0, class_validator_1.Min)(-2),
+    (0, class_validator_1.Max)(2),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "presence_penalty", void 0);
+__decorate([
+    (0, class_validator_1.Min)(-2),
+    (0, class_validator_1.Max)(2),
+    (0, class_validator_1.IsOptional)()
+], PromptParameters.prototype, "frequency_penalty", void 0);
+;
+/**
+ * Supported execution policy types.
+ *
+ * These policies decide how the gateway chooses the initial implementation
+ * order before retries / fallback logic is applied.
+ *
+ * Notes:
+ * - RetryPolicy is still responsible for retry attempts and failure handling.
+ * - ExecutionPolicy is responsible for candidate planning and prioritization.
+ */
+var ExecutionPolicyType;
+(function (ExecutionPolicyType) {
+    /**
+     * Use implementation weights as provided.
+     * This is the simplest and most backward-compatible mode.
+     */
+    ExecutionPolicyType["WEIGHTED"] = "WEIGHTED";
+    /**
+     * Use a fixed implementation order.
+     * The first active/healthy implementation is tried first, then the next one.
+     */
+    ExecutionPolicyType["FALLBACK_CHAIN"] = "FALLBACK_CHAIN";
+    /**
+     * Prefer local / office / on-prem implementations first.
+     * If none are available, use the remaining implementations.
+     */
+    ExecutionPolicyType["LOCAL_FIRST"] = "LOCAL_FIRST";
+    /**
+     * Prefer the cheapest implementations first.
+     * Requires each implementation to expose an estimated cost score.
+     */
+    ExecutionPolicyType["CHEAPEST_FIRST"] = "CHEAPEST_FIRST";
+    /**
+     * Prefer the fastest implementations first.
+     * Requires each implementation to expose an expected latency score.
+     */
+    ExecutionPolicyType["FASTEST_FIRST"] = "FASTEST_FIRST";
+    /**
+     * Prefer the highest-quality implementations first.
+     * Requires each implementation to expose a quality score.
+     */
+    ExecutionPolicyType["QUALITY_FIRST"] = "QUALITY_FIRST";
+})(ExecutionPolicyType || (exports.ExecutionPolicyType = ExecutionPolicyType = {}));
+/**
+ * Optional behavior when the selected policy cannot be fully evaluated.
+ *
+ * Example:
+ * - CHEAPEST_FIRST was requested, but implementations do not provide cost metadata.
+ */
+var ExecutionPolicyFallbackMode;
+(function (ExecutionPolicyFallbackMode) {
+    /**
+     * Fall back to simple weighted selection.
+     */
+    ExecutionPolicyFallbackMode["WEIGHTED"] = "WEIGHTED";
+    /**
+     * Fall back to the declared implementation order.
+     */
+    ExecutionPolicyFallbackMode["DECLARED_ORDER"] = "DECLARED_ORDER";
+    /**
+     * Fail fast if the policy cannot be evaluated correctly.
+     */
+    ExecutionPolicyFallbackMode["ERROR"] = "ERROR";
+})(ExecutionPolicyFallbackMode || (exports.ExecutionPolicyFallbackMode = ExecutionPolicyFallbackMode = {}));
+/**
+ * Exploration modes for candidate planning.
+ *
+ * Exploration is always explicit (opt-in) and is applied *after* deterministic ordering.
+ *
+ * V1 invariant
+ * - Do not combine weight-based selection with score-based ordering.
+ * - Exploration may reorder which candidate is tried first, but it must not change the underlying score ordering.
+ */
+var ExplorationMode;
+(function (ExplorationMode) {
+    /**
+     * Epsilon-greedy exploration over the top-K candidates.
+     *
+     * With probability `epsilon`, pick a random candidate in the top-K list.
+     * Otherwise, keep the deterministic best candidate.
+     */
+    ExplorationMode["EPSILON_GREEDY_TOP_K"] = "EPSILON_GREEDY_TOP_K";
+})(ExplorationMode || (exports.ExplorationMode = ExplorationMode = {}));