@adaptic/utils 0.1.49 → 0.1.50

package/dist/types/trading-policy/schemas/effective-policy.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effective-policy.schema.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/schemas/effective-policy.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAYrD;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;IAuBvC,oJAAoJ;;IAEpJ,uKAAuK;;IAEvK;;;;;;;;OAQG;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BH,CAAC;AAEH,8EAA8E;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC"}

package/dist/types/trading-policy/schemas/execution-prefs.schema.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+/**
+ * Execution preferences schema (section 7.5).
+ * Governs order routing behavior including order types, time-in-force,
+ * slippage tolerance, price collars, partial fill handling, and failure modes.
+ *
+ * The raw ZodObject variant (`ExecutionPrefsObjectSchema`) is exported
+ * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
+ */
+export declare const ExecutionPrefsObjectSchema: z.ZodObject<{
+    allowedOrderTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["market", "limit", "stop", "stop_limit", "trailing_stop"]>, "many">>;
+    preferredOrderType: z.ZodDefault<z.ZodEnum<["market", "limit", "stop", "stop_limit", "trailing_stop"]>>;
+    preferredOrderTypeByAssetClass: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaultTimeInForce: z.ZodDefault<z.ZodEnum<["day", "gtc", "ioc", "fok"]>>;
+    executionBias: z.ZodDefault<z.ZodEnum<["passive", "neutral", "aggressive"]>>;
+    maxSlippageTolerancePct: z.ZodDefault<z.ZodNumber>;
+    priceCollarEnabled: z.ZodDefault<z.ZodBoolean>;
+    priceCollarPct: z.ZodDefault<z.ZodNumber>;
+    repriceEnabled: z.ZodDefault<z.ZodBoolean>;
+    repriceMaxAttempts: z.ZodDefault<z.ZodNumber>;
+    repriceIntervalSeconds: z.ZodDefault<z.ZodNumber>;
+    cancelReplaceTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    partialFillPolicy: z.ZodDefault<z.ZodEnum<["accept_partial", "cancel_remainder", "replace_to_fill"]>>;
+    sizingMethod: z.ZodDefault<z.ZodEnum<["notional", "quantity"]>>;
+    lotRoundingBehavior: z.ZodDefault<z.ZodEnum<["round_down", "round_nearest", "round_up"]>>;
+    afterHoursExecutionBehavior: z.ZodDefault<z.ZodEnum<["limit_only", "no_execution", "normal"]>>;
+    failureBehavior: z.ZodDefault<z.ZodEnum<["fail_safe", "fail_open"]>>;
+}, "strip", z.ZodTypeAny, {
+    allowedOrderTypes: ("limit" | "market" | "stop" | "stop_limit" | "trailing_stop")[];
+    preferredOrderType: "limit" | "market" | "stop" | "stop_limit" | "trailing_stop";
+    preferredOrderTypeByAssetClass: Record<string, string>;
+    defaultTimeInForce: "day" | "gtc" | "ioc" | "fok";
+    executionBias: "passive" | "neutral" | "aggressive";
+    maxSlippageTolerancePct: number;
+    priceCollarEnabled: boolean;
+    priceCollarPct: number;
+    repriceEnabled: boolean;
+    repriceMaxAttempts: number;
+    repriceIntervalSeconds: number;
+    cancelReplaceTimeoutSeconds: number;
+    partialFillPolicy: "accept_partial" | "cancel_remainder" | "replace_to_fill";
+    sizingMethod: "notional" | "quantity";
+    lotRoundingBehavior: "round_down" | "round_nearest" | "round_up";
+    afterHoursExecutionBehavior: "limit_only" | "no_execution" | "normal";
+    failureBehavior: "fail_safe" | "fail_open";
+}, {
+    allowedOrderTypes?: ("limit" | "market" | "stop" | "stop_limit" | "trailing_stop")[] | undefined;
+    preferredOrderType?: "limit" | "market" | "stop" | "stop_limit" | "trailing_stop" | undefined;
+    preferredOrderTypeByAssetClass?: Record<string, string> | undefined;
+    defaultTimeInForce?: "day" | "gtc" | "ioc" | "fok" | undefined;
+    executionBias?: "passive" | "neutral" | "aggressive" | undefined;
+    maxSlippageTolerancePct?: number | undefined;
+    priceCollarEnabled?: boolean | undefined;
+    priceCollarPct?: number | undefined;
+    repriceEnabled?: boolean | undefined;
+    repriceMaxAttempts?: number | undefined;
+    repriceIntervalSeconds?: number | undefined;
+    cancelReplaceTimeoutSeconds?: number | undefined;
+    partialFillPolicy?: "accept_partial" | "cancel_remainder" | "replace_to_fill" | undefined;
+    sizingMethod?: "notional" | "quantity" | undefined;
+    lotRoundingBehavior?: "round_down" | "round_nearest" | "round_up" | undefined;
+    afterHoursExecutionBehavior?: "limit_only" | "no_execution" | "normal" | undefined;
+    failureBehavior?: "fail_safe" | "fail_open" | undefined;
+}>;
+export declare const ExecutionPrefsSchema: z.ZodDefault<z.ZodObject<{
+    allowedOrderTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["market", "limit", "stop", "stop_limit", "trailing_stop"]>, "many">>;
+    preferredOrderType: z.ZodDefault<z.ZodEnum<["market", "limit", "stop", "stop_limit", "trailing_stop"]>>;
+    preferredOrderTypeByAssetClass: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    defaultTimeInForce: z.ZodDefault<z.ZodEnum<["day", "gtc", "ioc", "fok"]>>;
+    executionBias: z.ZodDefault<z.ZodEnum<["passive", "neutral", "aggressive"]>>;
+    maxSlippageTolerancePct: z.ZodDefault<z.ZodNumber>;
+    priceCollarEnabled: z.ZodDefault<z.ZodBoolean>;
+    priceCollarPct: z.ZodDefault<z.ZodNumber>;
+    repriceEnabled: z.ZodDefault<z.ZodBoolean>;
+    repriceMaxAttempts: z.ZodDefault<z.ZodNumber>;
+    repriceIntervalSeconds: z.ZodDefault<z.ZodNumber>;
+    cancelReplaceTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    partialFillPolicy: z.ZodDefault<z.ZodEnum<["accept_partial", "cancel_remainder", "replace_to_fill"]>>;
+    sizingMethod: z.ZodDefault<z.ZodEnum<["notional", "quantity"]>>;
+    lotRoundingBehavior: z.ZodDefault<z.ZodEnum<["round_down", "round_nearest", "round_up"]>>;
+    afterHoursExecutionBehavior: z.ZodDefault<z.ZodEnum<["limit_only", "no_execution", "normal"]>>;
+    failureBehavior: z.ZodDefault<z.ZodEnum<["fail_safe", "fail_open"]>>;
+}, "strip", z.ZodTypeAny, {
+    allowedOrderTypes: ("limit" | "market" | "stop" | "stop_limit" | "trailing_stop")[];
+    preferredOrderType: "limit" | "market" | "stop" | "stop_limit" | "trailing_stop";
+    preferredOrderTypeByAssetClass: Record<string, string>;
+    defaultTimeInForce: "day" | "gtc" | "ioc" | "fok";
+    executionBias: "passive" | "neutral" | "aggressive";
+    maxSlippageTolerancePct: number;
+    priceCollarEnabled: boolean;
+    priceCollarPct: number;
+    repriceEnabled: boolean;
+    repriceMaxAttempts: number;
+    repriceIntervalSeconds: number;
+    cancelReplaceTimeoutSeconds: number;
+    partialFillPolicy: "accept_partial" | "cancel_remainder" | "replace_to_fill";
+    sizingMethod: "notional" | "quantity";
+    lotRoundingBehavior: "round_down" | "round_nearest" | "round_up";
+    afterHoursExecutionBehavior: "limit_only" | "no_execution" | "normal";
+    failureBehavior: "fail_safe" | "fail_open";
+}, {
+    allowedOrderTypes?: ("limit" | "market" | "stop" | "stop_limit" | "trailing_stop")[] | undefined;
+    preferredOrderType?: "limit" | "market" | "stop" | "stop_limit" | "trailing_stop" | undefined;
+    preferredOrderTypeByAssetClass?: Record<string, string> | undefined;
+    defaultTimeInForce?: "day" | "gtc" | "ioc" | "fok" | undefined;
+    executionBias?: "passive" | "neutral" | "aggressive" | undefined;
+    maxSlippageTolerancePct?: number | undefined;
+    priceCollarEnabled?: boolean | undefined;
+    priceCollarPct?: number | undefined;
+    repriceEnabled?: boolean | undefined;
+    repriceMaxAttempts?: number | undefined;
+    repriceIntervalSeconds?: number | undefined;
+    cancelReplaceTimeoutSeconds?: number | undefined;
+    partialFillPolicy?: "accept_partial" | "cancel_remainder" | "replace_to_fill" | undefined;
+    sizingMethod?: "notional" | "quantity" | undefined;
+    lotRoundingBehavior?: "round_down" | "round_nearest" | "round_up" | undefined;
+    afterHoursExecutionBehavior?: "limit_only" | "no_execution" | "normal" | undefined;
+    failureBehavior?: "fail_safe" | "fail_open" | undefined;
+}>>;
+/** Inferred TypeScript type for execution preferences. */
+export type ExecutionPrefs = z.infer<typeof ExecutionPrefsSchema>;
+//# sourceMappingURL=execution-prefs.schema.d.ts.map

package/dist/types/trading-policy/schemas/execution-prefs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-prefs.schema.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/schemas/execution-prefs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCrC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAE3E,0DAA0D;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/trading-policy/schemas/index.d.ts

@@ -0,0 +1,13 @@
+export { AutonomyPrefsObjectSchema, AutonomyPrefsSchema, type AutonomyPrefs, } from "./autonomy-prefs.schema";
+export { AssetUniversePrefsObjectSchema, AssetUniversePrefsSchema, type AssetUniversePrefs, } from "./asset-universe-prefs.schema";
+export { RiskBudgetPrefsObjectSchema, RiskBudgetPrefsSchema, type RiskBudgetPrefs, } from "./risk-budget-prefs.schema";
+export { SignalConsumptionPrefsObjectSchema, SignalConsumptionPrefsSchema, type SignalConsumptionPrefs, } from "./signal-consumption-prefs.schema";
+export { ExecutionPrefsObjectSchema, ExecutionPrefsSchema, type ExecutionPrefs, } from "./execution-prefs.schema";
+export { PositionManagementPrefsObjectSchema, PositionManagementPrefsSchema, type PositionManagementPrefs, } from "./position-management-prefs.schema";
+export { PortfolioConstructionPrefsObjectSchema, PortfolioConstructionPrefsSchema, type PortfolioConstructionPrefs, } from "./portfolio-construction-prefs.schema";
+export { OverlayResponsePrefsObjectSchema, OverlayResponsePrefsSchema, type OverlayResponsePrefs, } from "./overlay-response-prefs.schema";
+export { ModelPrefsObjectSchema, ModelPrefsSchema, type ModelPrefs, } from "./model-prefs.schema";
+export { AuditNotificationPrefsObjectSchema, AuditNotificationPrefsSchema, type AuditNotificationPrefs, } from "./audit-notification-prefs.schema";
+export { PolicyMutationSchema, type PolicyMutation, } from "./policy-mutation.schema";
+export { EffectiveTradingPolicySchema, type EffectiveTradingPolicy, } from "./effective-policy.schema";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/trading-policy/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,KAAK,aAAa,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,8BAA8B,EAC9B,wBAAwB,EACxB,KAAK,kBAAkB,GACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,eAAe,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,kCAAkC,EAClC,4BAA4B,EAC5B,KAAK,sBAAsB,GAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mCAAmC,EACnC,6BAA6B,EAC7B,KAAK,uBAAuB,GAC7B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,sCAAsC,EACtC,gCAAgC,EAChC,KAAK,0BAA0B,GAChC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,gCAAgC,EAChC,0BAA0B,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,UAAU,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kCAAkC,EAClC,4BAA4B,EAC5B,KAAK,sBAAsB,GAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,4BAA4B,EAC5B,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC"}

package/dist/types/trading-policy/schemas/model-prefs.schema.d.ts

@@ -0,0 +1,249 @@
+import { z } from "zod";
+import { LlmProvider } from "../enums";
+/**
+ * Model preferences schema (section 7.9).
+ * Governs LLM provider fallback chains, escalation triggers, cost limits,
+ * latency targets, tool permissions by tier, and memory retention settings.
+ *
+ * The raw ZodObject variant (`ModelPrefsObjectSchema`) is exported
+ * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
+ */
+export declare const ModelPrefsObjectSchema: z.ZodObject<{
+    miniFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    normalFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    advancedFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    escalateToAdvancedWhenConflicts: z.ZodDefault<z.ZodBoolean>;
+    escalateToAdvancedWhenHighExposure: z.ZodDefault<z.ZodBoolean>;
+    highExposureThresholdPct: z.ZodDefault<z.ZodNumber>;
+    escalateToAdvancedWhenMultipleOrders: z.ZodDefault<z.ZodBoolean>;
+    multipleOrdersThreshold: z.ZodDefault<z.ZodNumber>;
+    maxCostPerDayUsd: z.ZodDefault<z.ZodNumber>;
+    maxCostPerDecisionUsd: z.ZodDefault<z.ZodNumber>;
+    latencyTargetMs: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    toolUsePermissionsByTier: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        readTools: z.ZodDefault<z.ZodBoolean>;
+        writeTools: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readTools: boolean;
+        writeTools: boolean;
+    }, {
+        readTools?: boolean | undefined;
+        writeTools?: boolean | undefined;
+    }>>>;
+    memorySummaryCadenceMinutes: z.ZodDefault<z.ZodNumber>;
+    maxMemorySummariesRetained: z.ZodDefault<z.ZodNumber>;
+    excludedProvidersForWorkflows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    quantModelWeight: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    miniFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    normalFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    advancedFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    escalateToAdvancedWhenConflicts: boolean;
+    escalateToAdvancedWhenHighExposure: boolean;
+    highExposureThresholdPct: number;
+    escalateToAdvancedWhenMultipleOrders: boolean;
+    multipleOrdersThreshold: number;
+    maxCostPerDayUsd: number;
+    maxCostPerDecisionUsd: number;
+    latencyTargetMs: number;
+    timeoutMs: number;
+    maxRetries: number;
+    toolUsePermissionsByTier: Record<string, {
+        readTools: boolean;
+        writeTools: boolean;
+    }>;
+    memorySummaryCadenceMinutes: number;
+    maxMemorySummariesRetained: number;
+    excludedProvidersForWorkflows: Record<string, string[]>;
+    quantModelWeight: number;
+}, {
+    miniFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    normalFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    advancedFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    escalateToAdvancedWhenConflicts?: boolean | undefined;
+    escalateToAdvancedWhenHighExposure?: boolean | undefined;
+    highExposureThresholdPct?: number | undefined;
+    escalateToAdvancedWhenMultipleOrders?: boolean | undefined;
+    multipleOrdersThreshold?: number | undefined;
+    maxCostPerDayUsd?: number | undefined;
+    maxCostPerDecisionUsd?: number | undefined;
+    latencyTargetMs?: number | undefined;
+    timeoutMs?: number | undefined;
+    maxRetries?: number | undefined;
+    toolUsePermissionsByTier?: Record<string, {
+        readTools?: boolean | undefined;
+        writeTools?: boolean | undefined;
+    }> | undefined;
+    memorySummaryCadenceMinutes?: number | undefined;
+    maxMemorySummariesRetained?: number | undefined;
+    excludedProvidersForWorkflows?: Record<string, string[]> | undefined;
+    quantModelWeight?: number | undefined;
+}>;
+export declare const ModelPrefsSchema: z.ZodDefault<z.ZodObject<{
+    miniFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    normalFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    advancedFallbackChain: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodNativeEnum<typeof LlmProvider>;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: LlmProvider;
+        modelId: string;
+    }, {
+        provider: LlmProvider;
+        modelId: string;
+    }>, "many">>;
+    escalateToAdvancedWhenConflicts: z.ZodDefault<z.ZodBoolean>;
+    escalateToAdvancedWhenHighExposure: z.ZodDefault<z.ZodBoolean>;
+    highExposureThresholdPct: z.ZodDefault<z.ZodNumber>;
+    escalateToAdvancedWhenMultipleOrders: z.ZodDefault<z.ZodBoolean>;
+    multipleOrdersThreshold: z.ZodDefault<z.ZodNumber>;
+    maxCostPerDayUsd: z.ZodDefault<z.ZodNumber>;
+    maxCostPerDecisionUsd: z.ZodDefault<z.ZodNumber>;
+    latencyTargetMs: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    toolUsePermissionsByTier: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        readTools: z.ZodDefault<z.ZodBoolean>;
+        writeTools: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readTools: boolean;
+        writeTools: boolean;
+    }, {
+        readTools?: boolean | undefined;
+        writeTools?: boolean | undefined;
+    }>>>;
+    memorySummaryCadenceMinutes: z.ZodDefault<z.ZodNumber>;
+    maxMemorySummariesRetained: z.ZodDefault<z.ZodNumber>;
+    excludedProvidersForWorkflows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    quantModelWeight: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    miniFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    normalFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    advancedFallbackChain: {
+        provider: LlmProvider;
+        modelId: string;
+    }[];
+    escalateToAdvancedWhenConflicts: boolean;
+    escalateToAdvancedWhenHighExposure: boolean;
+    highExposureThresholdPct: number;
+    escalateToAdvancedWhenMultipleOrders: boolean;
+    multipleOrdersThreshold: number;
+    maxCostPerDayUsd: number;
+    maxCostPerDecisionUsd: number;
+    latencyTargetMs: number;
+    timeoutMs: number;
+    maxRetries: number;
+    toolUsePermissionsByTier: Record<string, {
+        readTools: boolean;
+        writeTools: boolean;
+    }>;
+    memorySummaryCadenceMinutes: number;
+    maxMemorySummariesRetained: number;
+    excludedProvidersForWorkflows: Record<string, string[]>;
+    quantModelWeight: number;
+}, {
+    miniFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    normalFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    advancedFallbackChain?: {
+        provider: LlmProvider;
+        modelId: string;
+    }[] | undefined;
+    escalateToAdvancedWhenConflicts?: boolean | undefined;
+    escalateToAdvancedWhenHighExposure?: boolean | undefined;
+    highExposureThresholdPct?: number | undefined;
+    escalateToAdvancedWhenMultipleOrders?: boolean | undefined;
+    multipleOrdersThreshold?: number | undefined;
+    maxCostPerDayUsd?: number | undefined;
+    maxCostPerDecisionUsd?: number | undefined;
+    latencyTargetMs?: number | undefined;
+    timeoutMs?: number | undefined;
+    maxRetries?: number | undefined;
+    toolUsePermissionsByTier?: Record<string, {
+        readTools?: boolean | undefined;
+        writeTools?: boolean | undefined;
+    }> | undefined;
+    memorySummaryCadenceMinutes?: number | undefined;
+    maxMemorySummariesRetained?: number | undefined;
+    excludedProvidersForWorkflows?: Record<string, string[]> | undefined;
+    quantModelWeight?: number | undefined;
+}>>;
+/** Inferred TypeScript type for model preferences. */
+export type ModelPrefs = z.infer<typeof ModelPrefsSchema>;
+//# sourceMappingURL=model-prefs.schema.d.ts.map

package/dist/types/trading-policy/schemas/model-prefs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-prefs.schema.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/schemas/model-prefs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAcvC;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BjC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC;AAEnE,sDAAsD;AACtD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/types/trading-policy/schemas/overlay-response-prefs.schema.d.ts

@@ -0,0 +1,217 @@
+import { z } from "zod";
+import { OverlayType } from "../enums";
+/**
+ * Overlay response preferences schema (section 7.8).
+ * Maps overlay types to specific response configurations that modify
+ * trading behavior when protective overlays are triggered.
+ *
+ * The raw ZodObject variant (`OverlayResponsePrefsObjectSchema`) is exported
+ * for use with `deepPartial()`, which requires a ZodObject (not ZodDefault).
+ */
+export declare const OverlayResponsePrefsObjectSchema: z.ZodObject<{
+    overlayResponses: z.ZodDefault<z.ZodRecord<z.ZodNativeEnum<typeof OverlayType>, z.ZodObject<{
+        pauseRealtimeTrading: z.ZodDefault<z.ZodBoolean>;
+        pauseNewEntriesOnly: z.ZodDefault<z.ZodBoolean>;
+        cancelAllOpenOrders: z.ZodDefault<z.ZodBoolean>;
+        tightenStops: z.ZodDefault<z.ZodBoolean>;
+        tightenStopsByPct: z.ZodDefault<z.ZodNumber>;
+        reduceRiskBudgets: z.ZodDefault<z.ZodBoolean>;
+        reduceRiskBudgetsByPct: z.ZodDefault<z.ZodNumber>;
+        rebalanceToTargetAllocation: z.ZodDefault<z.ZodBoolean>;
+        raiseCash: z.ZodDefault<z.ZodBoolean>;
+        raiseCashTargetPct: z.ZodDefault<z.ZodNumber>;
+        unwindSpecificSectors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        unwindSpecificAssetClasses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        closeAllPositions: z.ZodDefault<z.ZodBoolean>;
+        switchToManualApproval: z.ZodDefault<z.ZodBoolean>;
+        downgradeExecutionAggressiveness: z.ZodDefault<z.ZodBoolean>;
+        switchModelTier: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        extendCooldowns: z.ZodDefault<z.ZodBoolean>;
+        extendCooldownMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        pauseRealtimeTrading: boolean;
+        pauseNewEntriesOnly: boolean;
+        cancelAllOpenOrders: boolean;
+        tightenStops: boolean;
+        tightenStopsByPct: number;
+        reduceRiskBudgets: boolean;
+        reduceRiskBudgetsByPct: number;
+        rebalanceToTargetAllocation: boolean;
+        raiseCash: boolean;
+        raiseCashTargetPct: number;
+        unwindSpecificSectors: string[];
+        unwindSpecificAssetClasses: string[];
+        closeAllPositions: boolean;
+        switchToManualApproval: boolean;
+        downgradeExecutionAggressiveness: boolean;
+        switchModelTier: string | null;
+        extendCooldowns: boolean;
+        extendCooldownMultiplier: number;
+    }, {
+        pauseRealtimeTrading?: boolean | undefined;
+        pauseNewEntriesOnly?: boolean | undefined;
+        cancelAllOpenOrders?: boolean | undefined;
+        tightenStops?: boolean | undefined;
+        tightenStopsByPct?: number | undefined;
+        reduceRiskBudgets?: boolean | undefined;
+        reduceRiskBudgetsByPct?: number | undefined;
+        rebalanceToTargetAllocation?: boolean | undefined;
+        raiseCash?: boolean | undefined;
+        raiseCashTargetPct?: number | undefined;
+        unwindSpecificSectors?: string[] | undefined;
+        unwindSpecificAssetClasses?: string[] | undefined;
+        closeAllPositions?: boolean | undefined;
+        switchToManualApproval?: boolean | undefined;
+        downgradeExecutionAggressiveness?: boolean | undefined;
+        switchModelTier?: string | null | undefined;
+        extendCooldowns?: boolean | undefined;
+        extendCooldownMultiplier?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    overlayResponses: Partial<Record<OverlayType, {
+        pauseRealtimeTrading: boolean;
+        pauseNewEntriesOnly: boolean;
+        cancelAllOpenOrders: boolean;
+        tightenStops: boolean;
+        tightenStopsByPct: number;
+        reduceRiskBudgets: boolean;
+        reduceRiskBudgetsByPct: number;
+        rebalanceToTargetAllocation: boolean;
+        raiseCash: boolean;
+        raiseCashTargetPct: number;
+        unwindSpecificSectors: string[];
+        unwindSpecificAssetClasses: string[];
+        closeAllPositions: boolean;
+        switchToManualApproval: boolean;
+        downgradeExecutionAggressiveness: boolean;
+        switchModelTier: string | null;
+        extendCooldowns: boolean;
+        extendCooldownMultiplier: number;
+    }>>;
+}, {
+    overlayResponses?: Partial<Record<OverlayType, {
+        pauseRealtimeTrading?: boolean | undefined;
+        pauseNewEntriesOnly?: boolean | undefined;
+        cancelAllOpenOrders?: boolean | undefined;
+        tightenStops?: boolean | undefined;
+        tightenStopsByPct?: number | undefined;
+        reduceRiskBudgets?: boolean | undefined;
+        reduceRiskBudgetsByPct?: number | undefined;
+        rebalanceToTargetAllocation?: boolean | undefined;
+        raiseCash?: boolean | undefined;
+        raiseCashTargetPct?: number | undefined;
+        unwindSpecificSectors?: string[] | undefined;
+        unwindSpecificAssetClasses?: string[] | undefined;
+        closeAllPositions?: boolean | undefined;
+        switchToManualApproval?: boolean | undefined;
+        downgradeExecutionAggressiveness?: boolean | undefined;
+        switchModelTier?: string | null | undefined;
+        extendCooldowns?: boolean | undefined;
+        extendCooldownMultiplier?: number | undefined;
+    }>> | undefined;
+}>;
+export declare const OverlayResponsePrefsSchema: z.ZodDefault<z.ZodObject<{
+    overlayResponses: z.ZodDefault<z.ZodRecord<z.ZodNativeEnum<typeof OverlayType>, z.ZodObject<{
+        pauseRealtimeTrading: z.ZodDefault<z.ZodBoolean>;
+        pauseNewEntriesOnly: z.ZodDefault<z.ZodBoolean>;
+        cancelAllOpenOrders: z.ZodDefault<z.ZodBoolean>;
+        tightenStops: z.ZodDefault<z.ZodBoolean>;
+        tightenStopsByPct: z.ZodDefault<z.ZodNumber>;
+        reduceRiskBudgets: z.ZodDefault<z.ZodBoolean>;
+        reduceRiskBudgetsByPct: z.ZodDefault<z.ZodNumber>;
+        rebalanceToTargetAllocation: z.ZodDefault<z.ZodBoolean>;
+        raiseCash: z.ZodDefault<z.ZodBoolean>;
+        raiseCashTargetPct: z.ZodDefault<z.ZodNumber>;
+        unwindSpecificSectors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        unwindSpecificAssetClasses: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        closeAllPositions: z.ZodDefault<z.ZodBoolean>;
+        switchToManualApproval: z.ZodDefault<z.ZodBoolean>;
+        downgradeExecutionAggressiveness: z.ZodDefault<z.ZodBoolean>;
+        switchModelTier: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        extendCooldowns: z.ZodDefault<z.ZodBoolean>;
+        extendCooldownMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        pauseRealtimeTrading: boolean;
+        pauseNewEntriesOnly: boolean;
+        cancelAllOpenOrders: boolean;
+        tightenStops: boolean;
+        tightenStopsByPct: number;
+        reduceRiskBudgets: boolean;
+        reduceRiskBudgetsByPct: number;
+        rebalanceToTargetAllocation: boolean;
+        raiseCash: boolean;
+        raiseCashTargetPct: number;
+        unwindSpecificSectors: string[];
+        unwindSpecificAssetClasses: string[];
+        closeAllPositions: boolean;
+        switchToManualApproval: boolean;
+        downgradeExecutionAggressiveness: boolean;
+        switchModelTier: string | null;
+        extendCooldowns: boolean;
+        extendCooldownMultiplier: number;
+    }, {
+        pauseRealtimeTrading?: boolean | undefined;
+        pauseNewEntriesOnly?: boolean | undefined;
+        cancelAllOpenOrders?: boolean | undefined;
+        tightenStops?: boolean | undefined;
+        tightenStopsByPct?: number | undefined;
+        reduceRiskBudgets?: boolean | undefined;
+        reduceRiskBudgetsByPct?: number | undefined;
+        rebalanceToTargetAllocation?: boolean | undefined;
+        raiseCash?: boolean | undefined;
+        raiseCashTargetPct?: number | undefined;
+        unwindSpecificSectors?: string[] | undefined;
+        unwindSpecificAssetClasses?: string[] | undefined;
+        closeAllPositions?: boolean | undefined;
+        switchToManualApproval?: boolean | undefined;
+        downgradeExecutionAggressiveness?: boolean | undefined;
+        switchModelTier?: string | null | undefined;
+        extendCooldowns?: boolean | undefined;
+        extendCooldownMultiplier?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    overlayResponses: Partial<Record<OverlayType, {
+        pauseRealtimeTrading: boolean;
+        pauseNewEntriesOnly: boolean;
+        cancelAllOpenOrders: boolean;
+        tightenStops: boolean;
+        tightenStopsByPct: number;
+        reduceRiskBudgets: boolean;
+        reduceRiskBudgetsByPct: number;
+        rebalanceToTargetAllocation: boolean;
+        raiseCash: boolean;
+        raiseCashTargetPct: number;
+        unwindSpecificSectors: string[];
+        unwindSpecificAssetClasses: string[];
+        closeAllPositions: boolean;
+        switchToManualApproval: boolean;
+        downgradeExecutionAggressiveness: boolean;
+        switchModelTier: string | null;
+        extendCooldowns: boolean;
+        extendCooldownMultiplier: number;
+    }>>;
+}, {
+    overlayResponses?: Partial<Record<OverlayType, {
+        pauseRealtimeTrading?: boolean | undefined;
+        pauseNewEntriesOnly?: boolean | undefined;
+        cancelAllOpenOrders?: boolean | undefined;
+        tightenStops?: boolean | undefined;
+        tightenStopsByPct?: number | undefined;
+        reduceRiskBudgets?: boolean | undefined;
+        reduceRiskBudgetsByPct?: number | undefined;
+        rebalanceToTargetAllocation?: boolean | undefined;
+        raiseCash?: boolean | undefined;
+        raiseCashTargetPct?: number | undefined;
+        unwindSpecificSectors?: string[] | undefined;
+        unwindSpecificAssetClasses?: string[] | undefined;
+        closeAllPositions?: boolean | undefined;
+        switchToManualApproval?: boolean | undefined;
+        downgradeExecutionAggressiveness?: boolean | undefined;
+        switchModelTier?: string | null | undefined;
+        extendCooldowns?: boolean | undefined;
+        extendCooldownMultiplier?: number | undefined;
+    }>> | undefined;
+}>>;
+/** Inferred TypeScript type for overlay response preferences. */
+export type OverlayResponsePrefs = z.infer<typeof OverlayResponsePrefsSchema>;
+//# sourceMappingURL=overlay-response-prefs.schema.d.ts.map

package/dist/types/trading-policy/schemas/overlay-response-prefs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-response-prefs.schema.d.ts","sourceRoot":"","sources":["../../../../src/trading-policy/schemas/overlay-response-prefs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAwBvC;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GACO,CAAC;AAE/C,iEAAiE;AACjE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}