@crewhaus/spec 0.2.0 → 0.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +2397 -106
- package/dist/index.js +104 -3
- package/package.json +2 -2
package/dist/index.d.ts
CHANGED
|
@@ -152,6 +152,141 @@ declare const modelTiersBlock: z.ZodOptional<z.ZodObject<{
|
|
|
152
152
|
priorToolDensityThreshold?: number | undefined;
|
|
153
153
|
} | undefined;
|
|
154
154
|
}>>;
|
|
155
|
+
/**
|
|
156
|
+
* Adaptive model routing — an opt-in `model_pool` of user-declared candidate
|
|
157
|
+
* models the runtime selects among PER TURN, with a selection `policy` that can
|
|
158
|
+
* improve the more the harness runs. The N-candidate generalisation of
|
|
159
|
+
* `model_tiers` (which is the two-candidate special case), so the two are
|
|
160
|
+
* mutually exclusive on an agent block (enforced by a refine on each shape).
|
|
161
|
+
*
|
|
162
|
+
* The user always declares the SET; the runtime only ever picks WITHIN it —
|
|
163
|
+
* `agent.model` (and the optimizer's model-path exclusion) is untouched, so
|
|
164
|
+
* learning tunes selection policy, never the candidate roster.
|
|
165
|
+
*
|
|
166
|
+
* - `candidates` — ≥2 model-router grammar strings, each with free-form
|
|
167
|
+
* `tags` (e.g. `cheap`, `strong`) the heuristic routes on. Declare
|
|
168
|
+
* cheapest→strongest; tags override that order.
|
|
169
|
+
* - `policy` — `static` (first candidate), `heuristic` (deterministic
|
|
170
|
+
* difficulty routing, the default), or `learned` (reward-scoreboard arm
|
|
171
|
+
* selection that improves with usage).
|
|
172
|
+
* - `objective` — weights for the learned reward (quality / cost / latency);
|
|
173
|
+
* defaults to quality-dominant (0.7 / 0.2 / 0.1).
|
|
174
|
+
* - `routing` — difficulty thresholds (shared with `model_tiers`) plus the
|
|
175
|
+
* `strongTag`/`cheapTag` the heuristic prefers.
|
|
176
|
+
* - `learning` — read only for `policy: learned`: the per-arm exploration
|
|
177
|
+
* floor and the cost/latency reward references.
|
|
178
|
+
*
|
|
179
|
+
* Omitted entirely → single-model behaviour, byte-identical bundles.
|
|
180
|
+
*/
|
|
181
|
+
declare const modelPoolBlock: z.ZodOptional<z.ZodObject<{
|
|
182
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
183
|
+
model: z.ZodString;
|
|
184
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
185
|
+
}, "strict", z.ZodTypeAny, {
|
|
186
|
+
model: string;
|
|
187
|
+
tags: string[];
|
|
188
|
+
}, {
|
|
189
|
+
model: string;
|
|
190
|
+
tags?: string[] | undefined;
|
|
191
|
+
}>, "many">;
|
|
192
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
193
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
194
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
195
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
196
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
197
|
+
}, "strict", z.ZodTypeAny, {
|
|
198
|
+
quality?: number | undefined;
|
|
199
|
+
cost?: number | undefined;
|
|
200
|
+
latency?: number | undefined;
|
|
201
|
+
}, {
|
|
202
|
+
quality?: number | undefined;
|
|
203
|
+
cost?: number | undefined;
|
|
204
|
+
latency?: number | undefined;
|
|
205
|
+
}>>;
|
|
206
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
207
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
208
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
209
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
210
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
211
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
212
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
213
|
+
}, "strict", z.ZodTypeAny, {
|
|
214
|
+
contextTokenThreshold?: number | undefined;
|
|
215
|
+
toolsToDefault?: boolean | undefined;
|
|
216
|
+
firstTurnToDefault?: boolean | undefined;
|
|
217
|
+
priorToolDensityThreshold?: number | undefined;
|
|
218
|
+
strongTag?: string | undefined;
|
|
219
|
+
cheapTag?: string | undefined;
|
|
220
|
+
}, {
|
|
221
|
+
contextTokenThreshold?: number | undefined;
|
|
222
|
+
toolsToDefault?: boolean | undefined;
|
|
223
|
+
firstTurnToDefault?: boolean | undefined;
|
|
224
|
+
priorToolDensityThreshold?: number | undefined;
|
|
225
|
+
strongTag?: string | undefined;
|
|
226
|
+
cheapTag?: string | undefined;
|
|
227
|
+
}>>;
|
|
228
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
229
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
230
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
231
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
232
|
+
}, "strict", z.ZodTypeAny, {
|
|
233
|
+
minSamplesPerArm?: number | undefined;
|
|
234
|
+
costRefUsd?: number | undefined;
|
|
235
|
+
latencyRefMs?: number | undefined;
|
|
236
|
+
}, {
|
|
237
|
+
minSamplesPerArm?: number | undefined;
|
|
238
|
+
costRefUsd?: number | undefined;
|
|
239
|
+
latencyRefMs?: number | undefined;
|
|
240
|
+
}>>;
|
|
241
|
+
}, "strict", z.ZodTypeAny, {
|
|
242
|
+
candidates: {
|
|
243
|
+
model: string;
|
|
244
|
+
tags: string[];
|
|
245
|
+
}[];
|
|
246
|
+
policy: "static" | "heuristic" | "learned";
|
|
247
|
+
routing?: {
|
|
248
|
+
contextTokenThreshold?: number | undefined;
|
|
249
|
+
toolsToDefault?: boolean | undefined;
|
|
250
|
+
firstTurnToDefault?: boolean | undefined;
|
|
251
|
+
priorToolDensityThreshold?: number | undefined;
|
|
252
|
+
strongTag?: string | undefined;
|
|
253
|
+
cheapTag?: string | undefined;
|
|
254
|
+
} | undefined;
|
|
255
|
+
objective?: {
|
|
256
|
+
quality?: number | undefined;
|
|
257
|
+
cost?: number | undefined;
|
|
258
|
+
latency?: number | undefined;
|
|
259
|
+
} | undefined;
|
|
260
|
+
learning?: {
|
|
261
|
+
minSamplesPerArm?: number | undefined;
|
|
262
|
+
costRefUsd?: number | undefined;
|
|
263
|
+
latencyRefMs?: number | undefined;
|
|
264
|
+
} | undefined;
|
|
265
|
+
}, {
|
|
266
|
+
candidates: {
|
|
267
|
+
model: string;
|
|
268
|
+
tags?: string[] | undefined;
|
|
269
|
+
}[];
|
|
270
|
+
routing?: {
|
|
271
|
+
contextTokenThreshold?: number | undefined;
|
|
272
|
+
toolsToDefault?: boolean | undefined;
|
|
273
|
+
firstTurnToDefault?: boolean | undefined;
|
|
274
|
+
priorToolDensityThreshold?: number | undefined;
|
|
275
|
+
strongTag?: string | undefined;
|
|
276
|
+
cheapTag?: string | undefined;
|
|
277
|
+
} | undefined;
|
|
278
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
279
|
+
objective?: {
|
|
280
|
+
quality?: number | undefined;
|
|
281
|
+
cost?: number | undefined;
|
|
282
|
+
latency?: number | undefined;
|
|
283
|
+
} | undefined;
|
|
284
|
+
learning?: {
|
|
285
|
+
minSamplesPerArm?: number | undefined;
|
|
286
|
+
costRefUsd?: number | undefined;
|
|
287
|
+
latencyRefMs?: number | undefined;
|
|
288
|
+
} | undefined;
|
|
289
|
+
}>>;
|
|
155
290
|
/**
|
|
156
291
|
* Section 17 — optional override for the model used by
|
|
157
292
|
* `compaction-autocompact` when summarising long conversations. Defaults
|
|
@@ -444,7 +579,7 @@ declare const cliSchema: z.ZodObject<{
|
|
|
444
579
|
name: z.ZodString;
|
|
445
580
|
version: z.ZodOptional<z.ZodNumber>;
|
|
446
581
|
target: z.ZodLiteral<"cli">;
|
|
447
|
-
agent: z.ZodObject<{
|
|
582
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
448
583
|
model: z.ZodString;
|
|
449
584
|
instructions: z.ZodString;
|
|
450
585
|
max_tokens: z.ZodOptional<z.ZodNumber>;
|
|
@@ -503,6 +638,115 @@ declare const cliSchema: z.ZodObject<{
|
|
|
503
638
|
priorToolDensityThreshold?: number | undefined;
|
|
504
639
|
} | undefined;
|
|
505
640
|
}>>;
|
|
641
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
642
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
643
|
+
model: z.ZodString;
|
|
644
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
645
|
+
}, "strict", z.ZodTypeAny, {
|
|
646
|
+
model: string;
|
|
647
|
+
tags: string[];
|
|
648
|
+
}, {
|
|
649
|
+
model: string;
|
|
650
|
+
tags?: string[] | undefined;
|
|
651
|
+
}>, "many">;
|
|
652
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
653
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
654
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
655
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
656
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
657
|
+
}, "strict", z.ZodTypeAny, {
|
|
658
|
+
quality?: number | undefined;
|
|
659
|
+
cost?: number | undefined;
|
|
660
|
+
latency?: number | undefined;
|
|
661
|
+
}, {
|
|
662
|
+
quality?: number | undefined;
|
|
663
|
+
cost?: number | undefined;
|
|
664
|
+
latency?: number | undefined;
|
|
665
|
+
}>>;
|
|
666
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
667
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
668
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
669
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
670
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
671
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
672
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
673
|
+
}, "strict", z.ZodTypeAny, {
|
|
674
|
+
contextTokenThreshold?: number | undefined;
|
|
675
|
+
toolsToDefault?: boolean | undefined;
|
|
676
|
+
firstTurnToDefault?: boolean | undefined;
|
|
677
|
+
priorToolDensityThreshold?: number | undefined;
|
|
678
|
+
strongTag?: string | undefined;
|
|
679
|
+
cheapTag?: string | undefined;
|
|
680
|
+
}, {
|
|
681
|
+
contextTokenThreshold?: number | undefined;
|
|
682
|
+
toolsToDefault?: boolean | undefined;
|
|
683
|
+
firstTurnToDefault?: boolean | undefined;
|
|
684
|
+
priorToolDensityThreshold?: number | undefined;
|
|
685
|
+
strongTag?: string | undefined;
|
|
686
|
+
cheapTag?: string | undefined;
|
|
687
|
+
}>>;
|
|
688
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
689
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
690
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
691
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
692
|
+
}, "strict", z.ZodTypeAny, {
|
|
693
|
+
minSamplesPerArm?: number | undefined;
|
|
694
|
+
costRefUsd?: number | undefined;
|
|
695
|
+
latencyRefMs?: number | undefined;
|
|
696
|
+
}, {
|
|
697
|
+
minSamplesPerArm?: number | undefined;
|
|
698
|
+
costRefUsd?: number | undefined;
|
|
699
|
+
latencyRefMs?: number | undefined;
|
|
700
|
+
}>>;
|
|
701
|
+
}, "strict", z.ZodTypeAny, {
|
|
702
|
+
candidates: {
|
|
703
|
+
model: string;
|
|
704
|
+
tags: string[];
|
|
705
|
+
}[];
|
|
706
|
+
policy: "static" | "heuristic" | "learned";
|
|
707
|
+
routing?: {
|
|
708
|
+
contextTokenThreshold?: number | undefined;
|
|
709
|
+
toolsToDefault?: boolean | undefined;
|
|
710
|
+
firstTurnToDefault?: boolean | undefined;
|
|
711
|
+
priorToolDensityThreshold?: number | undefined;
|
|
712
|
+
strongTag?: string | undefined;
|
|
713
|
+
cheapTag?: string | undefined;
|
|
714
|
+
} | undefined;
|
|
715
|
+
objective?: {
|
|
716
|
+
quality?: number | undefined;
|
|
717
|
+
cost?: number | undefined;
|
|
718
|
+
latency?: number | undefined;
|
|
719
|
+
} | undefined;
|
|
720
|
+
learning?: {
|
|
721
|
+
minSamplesPerArm?: number | undefined;
|
|
722
|
+
costRefUsd?: number | undefined;
|
|
723
|
+
latencyRefMs?: number | undefined;
|
|
724
|
+
} | undefined;
|
|
725
|
+
}, {
|
|
726
|
+
candidates: {
|
|
727
|
+
model: string;
|
|
728
|
+
tags?: string[] | undefined;
|
|
729
|
+
}[];
|
|
730
|
+
routing?: {
|
|
731
|
+
contextTokenThreshold?: number | undefined;
|
|
732
|
+
toolsToDefault?: boolean | undefined;
|
|
733
|
+
firstTurnToDefault?: boolean | undefined;
|
|
734
|
+
priorToolDensityThreshold?: number | undefined;
|
|
735
|
+
strongTag?: string | undefined;
|
|
736
|
+
cheapTag?: string | undefined;
|
|
737
|
+
} | undefined;
|
|
738
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
739
|
+
objective?: {
|
|
740
|
+
quality?: number | undefined;
|
|
741
|
+
cost?: number | undefined;
|
|
742
|
+
latency?: number | undefined;
|
|
743
|
+
} | undefined;
|
|
744
|
+
learning?: {
|
|
745
|
+
minSamplesPerArm?: number | undefined;
|
|
746
|
+
costRefUsd?: number | undefined;
|
|
747
|
+
latencyRefMs?: number | undefined;
|
|
748
|
+
} | undefined;
|
|
749
|
+
}>>;
|
|
506
750
|
sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
507
751
|
description: z.ZodString;
|
|
508
752
|
instructions: z.ZodString;
|
|
@@ -543,13 +787,62 @@ declare const cliSchema: z.ZodObject<{
|
|
|
543
787
|
}, "strict", z.ZodTypeAny, {
|
|
544
788
|
instructions: string;
|
|
545
789
|
model: string;
|
|
546
|
-
|
|
790
|
+
model_tiers?: {
|
|
791
|
+
default: string;
|
|
792
|
+
fast: string;
|
|
793
|
+
routing?: {
|
|
794
|
+
contextTokenThreshold?: number | undefined;
|
|
795
|
+
toolsToDefault?: boolean | undefined;
|
|
796
|
+
firstTurnToDefault?: boolean | undefined;
|
|
797
|
+
priorToolDensityThreshold?: number | undefined;
|
|
798
|
+
} | undefined;
|
|
799
|
+
} | undefined;
|
|
547
800
|
model_fallbacks?: string[] | undefined;
|
|
801
|
+
max_tokens?: number | undefined;
|
|
548
802
|
circuit_breaker?: {
|
|
549
803
|
failureThreshold?: number | undefined;
|
|
550
804
|
windowMs?: number | undefined;
|
|
551
805
|
cooldownMs?: number | undefined;
|
|
552
806
|
} | undefined;
|
|
807
|
+
model_pool?: {
|
|
808
|
+
candidates: {
|
|
809
|
+
model: string;
|
|
810
|
+
tags: string[];
|
|
811
|
+
}[];
|
|
812
|
+
policy: "static" | "heuristic" | "learned";
|
|
813
|
+
routing?: {
|
|
814
|
+
contextTokenThreshold?: number | undefined;
|
|
815
|
+
toolsToDefault?: boolean | undefined;
|
|
816
|
+
firstTurnToDefault?: boolean | undefined;
|
|
817
|
+
priorToolDensityThreshold?: number | undefined;
|
|
818
|
+
strongTag?: string | undefined;
|
|
819
|
+
cheapTag?: string | undefined;
|
|
820
|
+
} | undefined;
|
|
821
|
+
objective?: {
|
|
822
|
+
quality?: number | undefined;
|
|
823
|
+
cost?: number | undefined;
|
|
824
|
+
latency?: number | undefined;
|
|
825
|
+
} | undefined;
|
|
826
|
+
learning?: {
|
|
827
|
+
minSamplesPerArm?: number | undefined;
|
|
828
|
+
costRefUsd?: number | undefined;
|
|
829
|
+
latencyRefMs?: number | undefined;
|
|
830
|
+
} | undefined;
|
|
831
|
+
} | undefined;
|
|
832
|
+
sub_agents?: Record<string, {
|
|
833
|
+
description: string;
|
|
834
|
+
instructions: string;
|
|
835
|
+
tools?: string[] | undefined;
|
|
836
|
+
model?: string | undefined;
|
|
837
|
+
permissions?: "inherit" | "scoped" | {
|
|
838
|
+
allow: string[];
|
|
839
|
+
deny: string[];
|
|
840
|
+
} | undefined;
|
|
841
|
+
inherit_bypass?: boolean | undefined;
|
|
842
|
+
}> | undefined;
|
|
843
|
+
}, {
|
|
844
|
+
instructions: string;
|
|
845
|
+
model: string;
|
|
553
846
|
model_tiers?: {
|
|
554
847
|
default: string;
|
|
555
848
|
fast: string;
|
|
@@ -560,6 +853,38 @@ declare const cliSchema: z.ZodObject<{
|
|
|
560
853
|
priorToolDensityThreshold?: number | undefined;
|
|
561
854
|
} | undefined;
|
|
562
855
|
} | undefined;
|
|
856
|
+
model_fallbacks?: string[] | undefined;
|
|
857
|
+
max_tokens?: number | undefined;
|
|
858
|
+
circuit_breaker?: {
|
|
859
|
+
failureThreshold?: number | undefined;
|
|
860
|
+
windowMs?: number | undefined;
|
|
861
|
+
cooldownMs?: number | undefined;
|
|
862
|
+
} | undefined;
|
|
863
|
+
model_pool?: {
|
|
864
|
+
candidates: {
|
|
865
|
+
model: string;
|
|
866
|
+
tags?: string[] | undefined;
|
|
867
|
+
}[];
|
|
868
|
+
routing?: {
|
|
869
|
+
contextTokenThreshold?: number | undefined;
|
|
870
|
+
toolsToDefault?: boolean | undefined;
|
|
871
|
+
firstTurnToDefault?: boolean | undefined;
|
|
872
|
+
priorToolDensityThreshold?: number | undefined;
|
|
873
|
+
strongTag?: string | undefined;
|
|
874
|
+
cheapTag?: string | undefined;
|
|
875
|
+
} | undefined;
|
|
876
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
877
|
+
objective?: {
|
|
878
|
+
quality?: number | undefined;
|
|
879
|
+
cost?: number | undefined;
|
|
880
|
+
latency?: number | undefined;
|
|
881
|
+
} | undefined;
|
|
882
|
+
learning?: {
|
|
883
|
+
minSamplesPerArm?: number | undefined;
|
|
884
|
+
costRefUsd?: number | undefined;
|
|
885
|
+
latencyRefMs?: number | undefined;
|
|
886
|
+
} | undefined;
|
|
887
|
+
} | undefined;
|
|
563
888
|
sub_agents?: Record<string, {
|
|
564
889
|
description: string;
|
|
565
890
|
instructions: string;
|
|
@@ -571,16 +896,65 @@ declare const cliSchema: z.ZodObject<{
|
|
|
571
896
|
} | undefined;
|
|
572
897
|
inherit_bypass?: boolean | undefined;
|
|
573
898
|
}> | undefined;
|
|
574
|
-
}
|
|
899
|
+
}>, {
|
|
575
900
|
instructions: string;
|
|
576
901
|
model: string;
|
|
577
|
-
|
|
902
|
+
model_tiers?: {
|
|
903
|
+
default: string;
|
|
904
|
+
fast: string;
|
|
905
|
+
routing?: {
|
|
906
|
+
contextTokenThreshold?: number | undefined;
|
|
907
|
+
toolsToDefault?: boolean | undefined;
|
|
908
|
+
firstTurnToDefault?: boolean | undefined;
|
|
909
|
+
priorToolDensityThreshold?: number | undefined;
|
|
910
|
+
} | undefined;
|
|
911
|
+
} | undefined;
|
|
578
912
|
model_fallbacks?: string[] | undefined;
|
|
913
|
+
max_tokens?: number | undefined;
|
|
579
914
|
circuit_breaker?: {
|
|
580
915
|
failureThreshold?: number | undefined;
|
|
581
916
|
windowMs?: number | undefined;
|
|
582
917
|
cooldownMs?: number | undefined;
|
|
583
918
|
} | undefined;
|
|
919
|
+
model_pool?: {
|
|
920
|
+
candidates: {
|
|
921
|
+
model: string;
|
|
922
|
+
tags: string[];
|
|
923
|
+
}[];
|
|
924
|
+
policy: "static" | "heuristic" | "learned";
|
|
925
|
+
routing?: {
|
|
926
|
+
contextTokenThreshold?: number | undefined;
|
|
927
|
+
toolsToDefault?: boolean | undefined;
|
|
928
|
+
firstTurnToDefault?: boolean | undefined;
|
|
929
|
+
priorToolDensityThreshold?: number | undefined;
|
|
930
|
+
strongTag?: string | undefined;
|
|
931
|
+
cheapTag?: string | undefined;
|
|
932
|
+
} | undefined;
|
|
933
|
+
objective?: {
|
|
934
|
+
quality?: number | undefined;
|
|
935
|
+
cost?: number | undefined;
|
|
936
|
+
latency?: number | undefined;
|
|
937
|
+
} | undefined;
|
|
938
|
+
learning?: {
|
|
939
|
+
minSamplesPerArm?: number | undefined;
|
|
940
|
+
costRefUsd?: number | undefined;
|
|
941
|
+
latencyRefMs?: number | undefined;
|
|
942
|
+
} | undefined;
|
|
943
|
+
} | undefined;
|
|
944
|
+
sub_agents?: Record<string, {
|
|
945
|
+
description: string;
|
|
946
|
+
instructions: string;
|
|
947
|
+
tools?: string[] | undefined;
|
|
948
|
+
model?: string | undefined;
|
|
949
|
+
permissions?: "inherit" | "scoped" | {
|
|
950
|
+
allow: string[];
|
|
951
|
+
deny: string[];
|
|
952
|
+
} | undefined;
|
|
953
|
+
inherit_bypass?: boolean | undefined;
|
|
954
|
+
}> | undefined;
|
|
955
|
+
}, {
|
|
956
|
+
instructions: string;
|
|
957
|
+
model: string;
|
|
584
958
|
model_tiers?: {
|
|
585
959
|
default: string;
|
|
586
960
|
fast: string;
|
|
@@ -591,6 +965,38 @@ declare const cliSchema: z.ZodObject<{
|
|
|
591
965
|
priorToolDensityThreshold?: number | undefined;
|
|
592
966
|
} | undefined;
|
|
593
967
|
} | undefined;
|
|
968
|
+
model_fallbacks?: string[] | undefined;
|
|
969
|
+
max_tokens?: number | undefined;
|
|
970
|
+
circuit_breaker?: {
|
|
971
|
+
failureThreshold?: number | undefined;
|
|
972
|
+
windowMs?: number | undefined;
|
|
973
|
+
cooldownMs?: number | undefined;
|
|
974
|
+
} | undefined;
|
|
975
|
+
model_pool?: {
|
|
976
|
+
candidates: {
|
|
977
|
+
model: string;
|
|
978
|
+
tags?: string[] | undefined;
|
|
979
|
+
}[];
|
|
980
|
+
routing?: {
|
|
981
|
+
contextTokenThreshold?: number | undefined;
|
|
982
|
+
toolsToDefault?: boolean | undefined;
|
|
983
|
+
firstTurnToDefault?: boolean | undefined;
|
|
984
|
+
priorToolDensityThreshold?: number | undefined;
|
|
985
|
+
strongTag?: string | undefined;
|
|
986
|
+
cheapTag?: string | undefined;
|
|
987
|
+
} | undefined;
|
|
988
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
989
|
+
objective?: {
|
|
990
|
+
quality?: number | undefined;
|
|
991
|
+
cost?: number | undefined;
|
|
992
|
+
latency?: number | undefined;
|
|
993
|
+
} | undefined;
|
|
994
|
+
learning?: {
|
|
995
|
+
minSamplesPerArm?: number | undefined;
|
|
996
|
+
costRefUsd?: number | undefined;
|
|
997
|
+
latencyRefMs?: number | undefined;
|
|
998
|
+
} | undefined;
|
|
999
|
+
} | undefined;
|
|
594
1000
|
sub_agents?: Record<string, {
|
|
595
1001
|
description: string;
|
|
596
1002
|
instructions: string;
|
|
@@ -1083,21 +1489,46 @@ declare const cliSchema: z.ZodObject<{
|
|
|
1083
1489
|
agent: {
|
|
1084
1490
|
instructions: string;
|
|
1085
1491
|
model: string;
|
|
1086
|
-
|
|
1492
|
+
model_tiers?: {
|
|
1493
|
+
default: string;
|
|
1494
|
+
fast: string;
|
|
1495
|
+
routing?: {
|
|
1496
|
+
contextTokenThreshold?: number | undefined;
|
|
1497
|
+
toolsToDefault?: boolean | undefined;
|
|
1498
|
+
firstTurnToDefault?: boolean | undefined;
|
|
1499
|
+
priorToolDensityThreshold?: number | undefined;
|
|
1500
|
+
} | undefined;
|
|
1501
|
+
} | undefined;
|
|
1087
1502
|
model_fallbacks?: string[] | undefined;
|
|
1503
|
+
max_tokens?: number | undefined;
|
|
1088
1504
|
circuit_breaker?: {
|
|
1089
1505
|
failureThreshold?: number | undefined;
|
|
1090
1506
|
windowMs?: number | undefined;
|
|
1091
1507
|
cooldownMs?: number | undefined;
|
|
1092
1508
|
} | undefined;
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1509
|
+
model_pool?: {
|
|
1510
|
+
candidates: {
|
|
1511
|
+
model: string;
|
|
1512
|
+
tags: string[];
|
|
1513
|
+
}[];
|
|
1514
|
+
policy: "static" | "heuristic" | "learned";
|
|
1096
1515
|
routing?: {
|
|
1097
1516
|
contextTokenThreshold?: number | undefined;
|
|
1098
1517
|
toolsToDefault?: boolean | undefined;
|
|
1099
1518
|
firstTurnToDefault?: boolean | undefined;
|
|
1100
1519
|
priorToolDensityThreshold?: number | undefined;
|
|
1520
|
+
strongTag?: string | undefined;
|
|
1521
|
+
cheapTag?: string | undefined;
|
|
1522
|
+
} | undefined;
|
|
1523
|
+
objective?: {
|
|
1524
|
+
quality?: number | undefined;
|
|
1525
|
+
cost?: number | undefined;
|
|
1526
|
+
latency?: number | undefined;
|
|
1527
|
+
} | undefined;
|
|
1528
|
+
learning?: {
|
|
1529
|
+
minSamplesPerArm?: number | undefined;
|
|
1530
|
+
costRefUsd?: number | undefined;
|
|
1531
|
+
latencyRefMs?: number | undefined;
|
|
1101
1532
|
} | undefined;
|
|
1102
1533
|
} | undefined;
|
|
1103
1534
|
sub_agents?: Record<string, {
|
|
@@ -1240,21 +1671,46 @@ declare const cliSchema: z.ZodObject<{
|
|
|
1240
1671
|
agent: {
|
|
1241
1672
|
instructions: string;
|
|
1242
1673
|
model: string;
|
|
1243
|
-
|
|
1674
|
+
model_tiers?: {
|
|
1675
|
+
default: string;
|
|
1676
|
+
fast: string;
|
|
1677
|
+
routing?: {
|
|
1678
|
+
contextTokenThreshold?: number | undefined;
|
|
1679
|
+
toolsToDefault?: boolean | undefined;
|
|
1680
|
+
firstTurnToDefault?: boolean | undefined;
|
|
1681
|
+
priorToolDensityThreshold?: number | undefined;
|
|
1682
|
+
} | undefined;
|
|
1683
|
+
} | undefined;
|
|
1244
1684
|
model_fallbacks?: string[] | undefined;
|
|
1685
|
+
max_tokens?: number | undefined;
|
|
1245
1686
|
circuit_breaker?: {
|
|
1246
1687
|
failureThreshold?: number | undefined;
|
|
1247
1688
|
windowMs?: number | undefined;
|
|
1248
1689
|
cooldownMs?: number | undefined;
|
|
1249
1690
|
} | undefined;
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1691
|
+
model_pool?: {
|
|
1692
|
+
candidates: {
|
|
1693
|
+
model: string;
|
|
1694
|
+
tags?: string[] | undefined;
|
|
1695
|
+
}[];
|
|
1253
1696
|
routing?: {
|
|
1254
1697
|
contextTokenThreshold?: number | undefined;
|
|
1255
1698
|
toolsToDefault?: boolean | undefined;
|
|
1256
1699
|
firstTurnToDefault?: boolean | undefined;
|
|
1257
1700
|
priorToolDensityThreshold?: number | undefined;
|
|
1701
|
+
strongTag?: string | undefined;
|
|
1702
|
+
cheapTag?: string | undefined;
|
|
1703
|
+
} | undefined;
|
|
1704
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
1705
|
+
objective?: {
|
|
1706
|
+
quality?: number | undefined;
|
|
1707
|
+
cost?: number | undefined;
|
|
1708
|
+
latency?: number | undefined;
|
|
1709
|
+
} | undefined;
|
|
1710
|
+
learning?: {
|
|
1711
|
+
minSamplesPerArm?: number | undefined;
|
|
1712
|
+
costRefUsd?: number | undefined;
|
|
1713
|
+
latencyRefMs?: number | undefined;
|
|
1258
1714
|
} | undefined;
|
|
1259
1715
|
} | undefined;
|
|
1260
1716
|
sub_agents?: Record<string, {
|
|
@@ -1855,7 +2311,7 @@ declare const imessageChannelSchema: z.ZodObject<{
|
|
|
1855
2311
|
chatDbPath?: string | undefined;
|
|
1856
2312
|
cursorPath?: string | undefined;
|
|
1857
2313
|
}>;
|
|
1858
|
-
declare const channelAgentSchema: z.ZodObject<{
|
|
2314
|
+
declare const channelAgentSchema: z.ZodEffects<z.ZodObject<{
|
|
1859
2315
|
model: z.ZodString;
|
|
1860
2316
|
instructions: z.ZodString;
|
|
1861
2317
|
model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -1913,28 +2369,137 @@ declare const channelAgentSchema: z.ZodObject<{
|
|
|
1913
2369
|
priorToolDensityThreshold?: number | undefined;
|
|
1914
2370
|
} | undefined;
|
|
1915
2371
|
}>>;
|
|
1916
|
-
|
|
1917
|
-
|
|
1918
|
-
|
|
1919
|
-
|
|
1920
|
-
instructions: z.ZodString;
|
|
1921
|
-
tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
1922
|
-
model: z.ZodOptional<z.ZodString>;
|
|
1923
|
-
permissions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "scoped"]>, z.ZodObject<{
|
|
1924
|
-
allow: z.ZodArray<z.ZodString, "many">;
|
|
1925
|
-
deny: z.ZodArray<z.ZodString, "many">;
|
|
2372
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
2373
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
2374
|
+
model: z.ZodString;
|
|
2375
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
1926
2376
|
}, "strict", z.ZodTypeAny, {
|
|
1927
|
-
|
|
1928
|
-
|
|
2377
|
+
model: string;
|
|
2378
|
+
tags: string[];
|
|
1929
2379
|
}, {
|
|
1930
|
-
|
|
1931
|
-
|
|
1932
|
-
}
|
|
1933
|
-
|
|
1934
|
-
|
|
1935
|
-
|
|
1936
|
-
|
|
1937
|
-
|
|
2380
|
+
model: string;
|
|
2381
|
+
tags?: string[] | undefined;
|
|
2382
|
+
}>, "many">;
|
|
2383
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
2384
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
2385
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
2386
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
2387
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
2388
|
+
}, "strict", z.ZodTypeAny, {
|
|
2389
|
+
quality?: number | undefined;
|
|
2390
|
+
cost?: number | undefined;
|
|
2391
|
+
latency?: number | undefined;
|
|
2392
|
+
}, {
|
|
2393
|
+
quality?: number | undefined;
|
|
2394
|
+
cost?: number | undefined;
|
|
2395
|
+
latency?: number | undefined;
|
|
2396
|
+
}>>;
|
|
2397
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
2398
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2399
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
2400
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
2401
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2402
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
2403
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
2404
|
+
}, "strict", z.ZodTypeAny, {
|
|
2405
|
+
contextTokenThreshold?: number | undefined;
|
|
2406
|
+
toolsToDefault?: boolean | undefined;
|
|
2407
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2408
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2409
|
+
strongTag?: string | undefined;
|
|
2410
|
+
cheapTag?: string | undefined;
|
|
2411
|
+
}, {
|
|
2412
|
+
contextTokenThreshold?: number | undefined;
|
|
2413
|
+
toolsToDefault?: boolean | undefined;
|
|
2414
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2415
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2416
|
+
strongTag?: string | undefined;
|
|
2417
|
+
cheapTag?: string | undefined;
|
|
2418
|
+
}>>;
|
|
2419
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
2420
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
2421
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
2422
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
2423
|
+
}, "strict", z.ZodTypeAny, {
|
|
2424
|
+
minSamplesPerArm?: number | undefined;
|
|
2425
|
+
costRefUsd?: number | undefined;
|
|
2426
|
+
latencyRefMs?: number | undefined;
|
|
2427
|
+
}, {
|
|
2428
|
+
minSamplesPerArm?: number | undefined;
|
|
2429
|
+
costRefUsd?: number | undefined;
|
|
2430
|
+
latencyRefMs?: number | undefined;
|
|
2431
|
+
}>>;
|
|
2432
|
+
}, "strict", z.ZodTypeAny, {
|
|
2433
|
+
candidates: {
|
|
2434
|
+
model: string;
|
|
2435
|
+
tags: string[];
|
|
2436
|
+
}[];
|
|
2437
|
+
policy: "static" | "heuristic" | "learned";
|
|
2438
|
+
routing?: {
|
|
2439
|
+
contextTokenThreshold?: number | undefined;
|
|
2440
|
+
toolsToDefault?: boolean | undefined;
|
|
2441
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2442
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2443
|
+
strongTag?: string | undefined;
|
|
2444
|
+
cheapTag?: string | undefined;
|
|
2445
|
+
} | undefined;
|
|
2446
|
+
objective?: {
|
|
2447
|
+
quality?: number | undefined;
|
|
2448
|
+
cost?: number | undefined;
|
|
2449
|
+
latency?: number | undefined;
|
|
2450
|
+
} | undefined;
|
|
2451
|
+
learning?: {
|
|
2452
|
+
minSamplesPerArm?: number | undefined;
|
|
2453
|
+
costRefUsd?: number | undefined;
|
|
2454
|
+
latencyRefMs?: number | undefined;
|
|
2455
|
+
} | undefined;
|
|
2456
|
+
}, {
|
|
2457
|
+
candidates: {
|
|
2458
|
+
model: string;
|
|
2459
|
+
tags?: string[] | undefined;
|
|
2460
|
+
}[];
|
|
2461
|
+
routing?: {
|
|
2462
|
+
contextTokenThreshold?: number | undefined;
|
|
2463
|
+
toolsToDefault?: boolean | undefined;
|
|
2464
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2465
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2466
|
+
strongTag?: string | undefined;
|
|
2467
|
+
cheapTag?: string | undefined;
|
|
2468
|
+
} | undefined;
|
|
2469
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
2470
|
+
objective?: {
|
|
2471
|
+
quality?: number | undefined;
|
|
2472
|
+
cost?: number | undefined;
|
|
2473
|
+
latency?: number | undefined;
|
|
2474
|
+
} | undefined;
|
|
2475
|
+
learning?: {
|
|
2476
|
+
minSamplesPerArm?: number | undefined;
|
|
2477
|
+
costRefUsd?: number | undefined;
|
|
2478
|
+
latencyRefMs?: number | undefined;
|
|
2479
|
+
} | undefined;
|
|
2480
|
+
}>>;
|
|
2481
|
+
tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2482
|
+
tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
|
|
2483
|
+
sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
2484
|
+
description: z.ZodString;
|
|
2485
|
+
instructions: z.ZodString;
|
|
2486
|
+
tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2487
|
+
model: z.ZodOptional<z.ZodString>;
|
|
2488
|
+
permissions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "scoped"]>, z.ZodObject<{
|
|
2489
|
+
allow: z.ZodArray<z.ZodString, "many">;
|
|
2490
|
+
deny: z.ZodArray<z.ZodString, "many">;
|
|
2491
|
+
}, "strict", z.ZodTypeAny, {
|
|
2492
|
+
allow: string[];
|
|
2493
|
+
deny: string[];
|
|
2494
|
+
}, {
|
|
2495
|
+
allow: string[];
|
|
2496
|
+
deny: string[];
|
|
2497
|
+
}>]>>;
|
|
2498
|
+
inherit_bypass: z.ZodOptional<z.ZodBoolean>;
|
|
2499
|
+
}, "strict", z.ZodTypeAny, {
|
|
2500
|
+
description: string;
|
|
2501
|
+
instructions: string;
|
|
2502
|
+
tools?: string[] | undefined;
|
|
1938
2503
|
model?: string | undefined;
|
|
1939
2504
|
permissions?: "inherit" | "scoped" | {
|
|
1940
2505
|
allow: string[];
|
|
@@ -1956,12 +2521,63 @@ declare const channelAgentSchema: z.ZodObject<{
|
|
|
1956
2521
|
instructions: string;
|
|
1957
2522
|
model: string;
|
|
1958
2523
|
tools?: string[] | undefined;
|
|
2524
|
+
model_tiers?: {
|
|
2525
|
+
default: string;
|
|
2526
|
+
fast: string;
|
|
2527
|
+
routing?: {
|
|
2528
|
+
contextTokenThreshold?: number | undefined;
|
|
2529
|
+
toolsToDefault?: boolean | undefined;
|
|
2530
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2531
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2532
|
+
} | undefined;
|
|
2533
|
+
} | undefined;
|
|
1959
2534
|
model_fallbacks?: string[] | undefined;
|
|
1960
2535
|
circuit_breaker?: {
|
|
1961
2536
|
failureThreshold?: number | undefined;
|
|
1962
2537
|
windowMs?: number | undefined;
|
|
1963
2538
|
cooldownMs?: number | undefined;
|
|
1964
2539
|
} | undefined;
|
|
2540
|
+
model_pool?: {
|
|
2541
|
+
candidates: {
|
|
2542
|
+
model: string;
|
|
2543
|
+
tags: string[];
|
|
2544
|
+
}[];
|
|
2545
|
+
policy: "static" | "heuristic" | "learned";
|
|
2546
|
+
routing?: {
|
|
2547
|
+
contextTokenThreshold?: number | undefined;
|
|
2548
|
+
toolsToDefault?: boolean | undefined;
|
|
2549
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2550
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2551
|
+
strongTag?: string | undefined;
|
|
2552
|
+
cheapTag?: string | undefined;
|
|
2553
|
+
} | undefined;
|
|
2554
|
+
objective?: {
|
|
2555
|
+
quality?: number | undefined;
|
|
2556
|
+
cost?: number | undefined;
|
|
2557
|
+
latency?: number | undefined;
|
|
2558
|
+
} | undefined;
|
|
2559
|
+
learning?: {
|
|
2560
|
+
minSamplesPerArm?: number | undefined;
|
|
2561
|
+
costRefUsd?: number | undefined;
|
|
2562
|
+
latencyRefMs?: number | undefined;
|
|
2563
|
+
} | undefined;
|
|
2564
|
+
} | undefined;
|
|
2565
|
+
sub_agents?: Record<string, {
|
|
2566
|
+
description: string;
|
|
2567
|
+
instructions: string;
|
|
2568
|
+
tools?: string[] | undefined;
|
|
2569
|
+
model?: string | undefined;
|
|
2570
|
+
permissions?: "inherit" | "scoped" | {
|
|
2571
|
+
allow: string[];
|
|
2572
|
+
deny: string[];
|
|
2573
|
+
} | undefined;
|
|
2574
|
+
inherit_bypass?: boolean | undefined;
|
|
2575
|
+
}> | undefined;
|
|
2576
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
2577
|
+
}, {
|
|
2578
|
+
instructions: string;
|
|
2579
|
+
model: string;
|
|
2580
|
+
tools?: string[] | undefined;
|
|
1965
2581
|
model_tiers?: {
|
|
1966
2582
|
default: string;
|
|
1967
2583
|
fast: string;
|
|
@@ -1972,6 +2588,37 @@ declare const channelAgentSchema: z.ZodObject<{
|
|
|
1972
2588
|
priorToolDensityThreshold?: number | undefined;
|
|
1973
2589
|
} | undefined;
|
|
1974
2590
|
} | undefined;
|
|
2591
|
+
model_fallbacks?: string[] | undefined;
|
|
2592
|
+
circuit_breaker?: {
|
|
2593
|
+
failureThreshold?: number | undefined;
|
|
2594
|
+
windowMs?: number | undefined;
|
|
2595
|
+
cooldownMs?: number | undefined;
|
|
2596
|
+
} | undefined;
|
|
2597
|
+
model_pool?: {
|
|
2598
|
+
candidates: {
|
|
2599
|
+
model: string;
|
|
2600
|
+
tags?: string[] | undefined;
|
|
2601
|
+
}[];
|
|
2602
|
+
routing?: {
|
|
2603
|
+
contextTokenThreshold?: number | undefined;
|
|
2604
|
+
toolsToDefault?: boolean | undefined;
|
|
2605
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2606
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2607
|
+
strongTag?: string | undefined;
|
|
2608
|
+
cheapTag?: string | undefined;
|
|
2609
|
+
} | undefined;
|
|
2610
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
2611
|
+
objective?: {
|
|
2612
|
+
quality?: number | undefined;
|
|
2613
|
+
cost?: number | undefined;
|
|
2614
|
+
latency?: number | undefined;
|
|
2615
|
+
} | undefined;
|
|
2616
|
+
learning?: {
|
|
2617
|
+
minSamplesPerArm?: number | undefined;
|
|
2618
|
+
costRefUsd?: number | undefined;
|
|
2619
|
+
latencyRefMs?: number | undefined;
|
|
2620
|
+
} | undefined;
|
|
2621
|
+
} | undefined;
|
|
1975
2622
|
sub_agents?: Record<string, {
|
|
1976
2623
|
description: string;
|
|
1977
2624
|
instructions: string;
|
|
@@ -1984,16 +2631,67 @@ declare const channelAgentSchema: z.ZodObject<{
|
|
|
1984
2631
|
inherit_bypass?: boolean | undefined;
|
|
1985
2632
|
}> | undefined;
|
|
1986
2633
|
tool_config?: Record<string, unknown> | undefined;
|
|
1987
|
-
}
|
|
2634
|
+
}>, {
|
|
1988
2635
|
instructions: string;
|
|
1989
2636
|
model: string;
|
|
1990
2637
|
tools?: string[] | undefined;
|
|
2638
|
+
model_tiers?: {
|
|
2639
|
+
default: string;
|
|
2640
|
+
fast: string;
|
|
2641
|
+
routing?: {
|
|
2642
|
+
contextTokenThreshold?: number | undefined;
|
|
2643
|
+
toolsToDefault?: boolean | undefined;
|
|
2644
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2645
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2646
|
+
} | undefined;
|
|
2647
|
+
} | undefined;
|
|
1991
2648
|
model_fallbacks?: string[] | undefined;
|
|
1992
2649
|
circuit_breaker?: {
|
|
1993
2650
|
failureThreshold?: number | undefined;
|
|
1994
2651
|
windowMs?: number | undefined;
|
|
1995
2652
|
cooldownMs?: number | undefined;
|
|
1996
2653
|
} | undefined;
|
|
2654
|
+
model_pool?: {
|
|
2655
|
+
candidates: {
|
|
2656
|
+
model: string;
|
|
2657
|
+
tags: string[];
|
|
2658
|
+
}[];
|
|
2659
|
+
policy: "static" | "heuristic" | "learned";
|
|
2660
|
+
routing?: {
|
|
2661
|
+
contextTokenThreshold?: number | undefined;
|
|
2662
|
+
toolsToDefault?: boolean | undefined;
|
|
2663
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2664
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2665
|
+
strongTag?: string | undefined;
|
|
2666
|
+
cheapTag?: string | undefined;
|
|
2667
|
+
} | undefined;
|
|
2668
|
+
objective?: {
|
|
2669
|
+
quality?: number | undefined;
|
|
2670
|
+
cost?: number | undefined;
|
|
2671
|
+
latency?: number | undefined;
|
|
2672
|
+
} | undefined;
|
|
2673
|
+
learning?: {
|
|
2674
|
+
minSamplesPerArm?: number | undefined;
|
|
2675
|
+
costRefUsd?: number | undefined;
|
|
2676
|
+
latencyRefMs?: number | undefined;
|
|
2677
|
+
} | undefined;
|
|
2678
|
+
} | undefined;
|
|
2679
|
+
sub_agents?: Record<string, {
|
|
2680
|
+
description: string;
|
|
2681
|
+
instructions: string;
|
|
2682
|
+
tools?: string[] | undefined;
|
|
2683
|
+
model?: string | undefined;
|
|
2684
|
+
permissions?: "inherit" | "scoped" | {
|
|
2685
|
+
allow: string[];
|
|
2686
|
+
deny: string[];
|
|
2687
|
+
} | undefined;
|
|
2688
|
+
inherit_bypass?: boolean | undefined;
|
|
2689
|
+
}> | undefined;
|
|
2690
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
2691
|
+
}, {
|
|
2692
|
+
instructions: string;
|
|
2693
|
+
model: string;
|
|
2694
|
+
tools?: string[] | undefined;
|
|
1997
2695
|
model_tiers?: {
|
|
1998
2696
|
default: string;
|
|
1999
2697
|
fast: string;
|
|
@@ -2004,6 +2702,37 @@ declare const channelAgentSchema: z.ZodObject<{
|
|
|
2004
2702
|
priorToolDensityThreshold?: number | undefined;
|
|
2005
2703
|
} | undefined;
|
|
2006
2704
|
} | undefined;
|
|
2705
|
+
model_fallbacks?: string[] | undefined;
|
|
2706
|
+
circuit_breaker?: {
|
|
2707
|
+
failureThreshold?: number | undefined;
|
|
2708
|
+
windowMs?: number | undefined;
|
|
2709
|
+
cooldownMs?: number | undefined;
|
|
2710
|
+
} | undefined;
|
|
2711
|
+
model_pool?: {
|
|
2712
|
+
candidates: {
|
|
2713
|
+
model: string;
|
|
2714
|
+
tags?: string[] | undefined;
|
|
2715
|
+
}[];
|
|
2716
|
+
routing?: {
|
|
2717
|
+
contextTokenThreshold?: number | undefined;
|
|
2718
|
+
toolsToDefault?: boolean | undefined;
|
|
2719
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2720
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2721
|
+
strongTag?: string | undefined;
|
|
2722
|
+
cheapTag?: string | undefined;
|
|
2723
|
+
} | undefined;
|
|
2724
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
2725
|
+
objective?: {
|
|
2726
|
+
quality?: number | undefined;
|
|
2727
|
+
cost?: number | undefined;
|
|
2728
|
+
latency?: number | undefined;
|
|
2729
|
+
} | undefined;
|
|
2730
|
+
learning?: {
|
|
2731
|
+
minSamplesPerArm?: number | undefined;
|
|
2732
|
+
costRefUsd?: number | undefined;
|
|
2733
|
+
latencyRefMs?: number | undefined;
|
|
2734
|
+
} | undefined;
|
|
2735
|
+
} | undefined;
|
|
2007
2736
|
sub_agents?: Record<string, {
|
|
2008
2737
|
description: string;
|
|
2009
2738
|
instructions: string;
|
|
@@ -2021,7 +2750,7 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2021
2750
|
name: z.ZodString;
|
|
2022
2751
|
version: z.ZodOptional<z.ZodNumber>;
|
|
2023
2752
|
target: z.ZodLiteral<"channel">;
|
|
2024
|
-
agent: z.ZodObject<{
|
|
2753
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
2025
2754
|
model: z.ZodString;
|
|
2026
2755
|
instructions: z.ZodString;
|
|
2027
2756
|
model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -2079,6 +2808,115 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2079
2808
|
priorToolDensityThreshold?: number | undefined;
|
|
2080
2809
|
} | undefined;
|
|
2081
2810
|
}>>;
|
|
2811
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
2812
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
2813
|
+
model: z.ZodString;
|
|
2814
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
2815
|
+
}, "strict", z.ZodTypeAny, {
|
|
2816
|
+
model: string;
|
|
2817
|
+
tags: string[];
|
|
2818
|
+
}, {
|
|
2819
|
+
model: string;
|
|
2820
|
+
tags?: string[] | undefined;
|
|
2821
|
+
}>, "many">;
|
|
2822
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
2823
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
2824
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
2825
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
2826
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
2827
|
+
}, "strict", z.ZodTypeAny, {
|
|
2828
|
+
quality?: number | undefined;
|
|
2829
|
+
cost?: number | undefined;
|
|
2830
|
+
latency?: number | undefined;
|
|
2831
|
+
}, {
|
|
2832
|
+
quality?: number | undefined;
|
|
2833
|
+
cost?: number | undefined;
|
|
2834
|
+
latency?: number | undefined;
|
|
2835
|
+
}>>;
|
|
2836
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
2837
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2838
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
2839
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
2840
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
2841
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
2842
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
2843
|
+
}, "strict", z.ZodTypeAny, {
|
|
2844
|
+
contextTokenThreshold?: number | undefined;
|
|
2845
|
+
toolsToDefault?: boolean | undefined;
|
|
2846
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2847
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2848
|
+
strongTag?: string | undefined;
|
|
2849
|
+
cheapTag?: string | undefined;
|
|
2850
|
+
}, {
|
|
2851
|
+
contextTokenThreshold?: number | undefined;
|
|
2852
|
+
toolsToDefault?: boolean | undefined;
|
|
2853
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2854
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2855
|
+
strongTag?: string | undefined;
|
|
2856
|
+
cheapTag?: string | undefined;
|
|
2857
|
+
}>>;
|
|
2858
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
2859
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
2860
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
2861
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
2862
|
+
}, "strict", z.ZodTypeAny, {
|
|
2863
|
+
minSamplesPerArm?: number | undefined;
|
|
2864
|
+
costRefUsd?: number | undefined;
|
|
2865
|
+
latencyRefMs?: number | undefined;
|
|
2866
|
+
}, {
|
|
2867
|
+
minSamplesPerArm?: number | undefined;
|
|
2868
|
+
costRefUsd?: number | undefined;
|
|
2869
|
+
latencyRefMs?: number | undefined;
|
|
2870
|
+
}>>;
|
|
2871
|
+
}, "strict", z.ZodTypeAny, {
|
|
2872
|
+
candidates: {
|
|
2873
|
+
model: string;
|
|
2874
|
+
tags: string[];
|
|
2875
|
+
}[];
|
|
2876
|
+
policy: "static" | "heuristic" | "learned";
|
|
2877
|
+
routing?: {
|
|
2878
|
+
contextTokenThreshold?: number | undefined;
|
|
2879
|
+
toolsToDefault?: boolean | undefined;
|
|
2880
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2881
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2882
|
+
strongTag?: string | undefined;
|
|
2883
|
+
cheapTag?: string | undefined;
|
|
2884
|
+
} | undefined;
|
|
2885
|
+
objective?: {
|
|
2886
|
+
quality?: number | undefined;
|
|
2887
|
+
cost?: number | undefined;
|
|
2888
|
+
latency?: number | undefined;
|
|
2889
|
+
} | undefined;
|
|
2890
|
+
learning?: {
|
|
2891
|
+
minSamplesPerArm?: number | undefined;
|
|
2892
|
+
costRefUsd?: number | undefined;
|
|
2893
|
+
latencyRefMs?: number | undefined;
|
|
2894
|
+
} | undefined;
|
|
2895
|
+
}, {
|
|
2896
|
+
candidates: {
|
|
2897
|
+
model: string;
|
|
2898
|
+
tags?: string[] | undefined;
|
|
2899
|
+
}[];
|
|
2900
|
+
routing?: {
|
|
2901
|
+
contextTokenThreshold?: number | undefined;
|
|
2902
|
+
toolsToDefault?: boolean | undefined;
|
|
2903
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2904
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2905
|
+
strongTag?: string | undefined;
|
|
2906
|
+
cheapTag?: string | undefined;
|
|
2907
|
+
} | undefined;
|
|
2908
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
2909
|
+
objective?: {
|
|
2910
|
+
quality?: number | undefined;
|
|
2911
|
+
cost?: number | undefined;
|
|
2912
|
+
latency?: number | undefined;
|
|
2913
|
+
} | undefined;
|
|
2914
|
+
learning?: {
|
|
2915
|
+
minSamplesPerArm?: number | undefined;
|
|
2916
|
+
costRefUsd?: number | undefined;
|
|
2917
|
+
latencyRefMs?: number | undefined;
|
|
2918
|
+
} | undefined;
|
|
2919
|
+
}>>;
|
|
2082
2920
|
tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2083
2921
|
tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
|
|
2084
2922
|
sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -2122,20 +2960,159 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2122
2960
|
instructions: string;
|
|
2123
2961
|
model: string;
|
|
2124
2962
|
tools?: string[] | undefined;
|
|
2963
|
+
model_tiers?: {
|
|
2964
|
+
default: string;
|
|
2965
|
+
fast: string;
|
|
2966
|
+
routing?: {
|
|
2967
|
+
contextTokenThreshold?: number | undefined;
|
|
2968
|
+
toolsToDefault?: boolean | undefined;
|
|
2969
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2970
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2971
|
+
} | undefined;
|
|
2972
|
+
} | undefined;
|
|
2973
|
+
model_fallbacks?: string[] | undefined;
|
|
2974
|
+
circuit_breaker?: {
|
|
2975
|
+
failureThreshold?: number | undefined;
|
|
2976
|
+
windowMs?: number | undefined;
|
|
2977
|
+
cooldownMs?: number | undefined;
|
|
2978
|
+
} | undefined;
|
|
2979
|
+
model_pool?: {
|
|
2980
|
+
candidates: {
|
|
2981
|
+
model: string;
|
|
2982
|
+
tags: string[];
|
|
2983
|
+
}[];
|
|
2984
|
+
policy: "static" | "heuristic" | "learned";
|
|
2985
|
+
routing?: {
|
|
2986
|
+
contextTokenThreshold?: number | undefined;
|
|
2987
|
+
toolsToDefault?: boolean | undefined;
|
|
2988
|
+
firstTurnToDefault?: boolean | undefined;
|
|
2989
|
+
priorToolDensityThreshold?: number | undefined;
|
|
2990
|
+
strongTag?: string | undefined;
|
|
2991
|
+
cheapTag?: string | undefined;
|
|
2992
|
+
} | undefined;
|
|
2993
|
+
objective?: {
|
|
2994
|
+
quality?: number | undefined;
|
|
2995
|
+
cost?: number | undefined;
|
|
2996
|
+
latency?: number | undefined;
|
|
2997
|
+
} | undefined;
|
|
2998
|
+
learning?: {
|
|
2999
|
+
minSamplesPerArm?: number | undefined;
|
|
3000
|
+
costRefUsd?: number | undefined;
|
|
3001
|
+
latencyRefMs?: number | undefined;
|
|
3002
|
+
} | undefined;
|
|
3003
|
+
} | undefined;
|
|
3004
|
+
sub_agents?: Record<string, {
|
|
3005
|
+
description: string;
|
|
3006
|
+
instructions: string;
|
|
3007
|
+
tools?: string[] | undefined;
|
|
3008
|
+
model?: string | undefined;
|
|
3009
|
+
permissions?: "inherit" | "scoped" | {
|
|
3010
|
+
allow: string[];
|
|
3011
|
+
deny: string[];
|
|
3012
|
+
} | undefined;
|
|
3013
|
+
inherit_bypass?: boolean | undefined;
|
|
3014
|
+
}> | undefined;
|
|
3015
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
3016
|
+
}, {
|
|
3017
|
+
instructions: string;
|
|
3018
|
+
model: string;
|
|
3019
|
+
tools?: string[] | undefined;
|
|
3020
|
+
model_tiers?: {
|
|
3021
|
+
default: string;
|
|
3022
|
+
fast: string;
|
|
3023
|
+
routing?: {
|
|
3024
|
+
contextTokenThreshold?: number | undefined;
|
|
3025
|
+
toolsToDefault?: boolean | undefined;
|
|
3026
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3027
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3028
|
+
} | undefined;
|
|
3029
|
+
} | undefined;
|
|
3030
|
+
model_fallbacks?: string[] | undefined;
|
|
3031
|
+
circuit_breaker?: {
|
|
3032
|
+
failureThreshold?: number | undefined;
|
|
3033
|
+
windowMs?: number | undefined;
|
|
3034
|
+
cooldownMs?: number | undefined;
|
|
3035
|
+
} | undefined;
|
|
3036
|
+
model_pool?: {
|
|
3037
|
+
candidates: {
|
|
3038
|
+
model: string;
|
|
3039
|
+
tags?: string[] | undefined;
|
|
3040
|
+
}[];
|
|
3041
|
+
routing?: {
|
|
3042
|
+
contextTokenThreshold?: number | undefined;
|
|
3043
|
+
toolsToDefault?: boolean | undefined;
|
|
3044
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3045
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3046
|
+
strongTag?: string | undefined;
|
|
3047
|
+
cheapTag?: string | undefined;
|
|
3048
|
+
} | undefined;
|
|
3049
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
3050
|
+
objective?: {
|
|
3051
|
+
quality?: number | undefined;
|
|
3052
|
+
cost?: number | undefined;
|
|
3053
|
+
latency?: number | undefined;
|
|
3054
|
+
} | undefined;
|
|
3055
|
+
learning?: {
|
|
3056
|
+
minSamplesPerArm?: number | undefined;
|
|
3057
|
+
costRefUsd?: number | undefined;
|
|
3058
|
+
latencyRefMs?: number | undefined;
|
|
3059
|
+
} | undefined;
|
|
3060
|
+
} | undefined;
|
|
3061
|
+
sub_agents?: Record<string, {
|
|
3062
|
+
description: string;
|
|
3063
|
+
instructions: string;
|
|
3064
|
+
tools?: string[] | undefined;
|
|
3065
|
+
model?: string | undefined;
|
|
3066
|
+
permissions?: "inherit" | "scoped" | {
|
|
3067
|
+
allow: string[];
|
|
3068
|
+
deny: string[];
|
|
3069
|
+
} | undefined;
|
|
3070
|
+
inherit_bypass?: boolean | undefined;
|
|
3071
|
+
}> | undefined;
|
|
3072
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
3073
|
+
}>, {
|
|
3074
|
+
instructions: string;
|
|
3075
|
+
model: string;
|
|
3076
|
+
tools?: string[] | undefined;
|
|
3077
|
+
model_tiers?: {
|
|
3078
|
+
default: string;
|
|
3079
|
+
fast: string;
|
|
3080
|
+
routing?: {
|
|
3081
|
+
contextTokenThreshold?: number | undefined;
|
|
3082
|
+
toolsToDefault?: boolean | undefined;
|
|
3083
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3084
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3085
|
+
} | undefined;
|
|
3086
|
+
} | undefined;
|
|
2125
3087
|
model_fallbacks?: string[] | undefined;
|
|
2126
3088
|
circuit_breaker?: {
|
|
2127
3089
|
failureThreshold?: number | undefined;
|
|
2128
3090
|
windowMs?: number | undefined;
|
|
2129
3091
|
cooldownMs?: number | undefined;
|
|
2130
3092
|
} | undefined;
|
|
2131
|
-
|
|
2132
|
-
|
|
2133
|
-
|
|
3093
|
+
model_pool?: {
|
|
3094
|
+
candidates: {
|
|
3095
|
+
model: string;
|
|
3096
|
+
tags: string[];
|
|
3097
|
+
}[];
|
|
3098
|
+
policy: "static" | "heuristic" | "learned";
|
|
2134
3099
|
routing?: {
|
|
2135
3100
|
contextTokenThreshold?: number | undefined;
|
|
2136
3101
|
toolsToDefault?: boolean | undefined;
|
|
2137
3102
|
firstTurnToDefault?: boolean | undefined;
|
|
2138
3103
|
priorToolDensityThreshold?: number | undefined;
|
|
3104
|
+
strongTag?: string | undefined;
|
|
3105
|
+
cheapTag?: string | undefined;
|
|
3106
|
+
} | undefined;
|
|
3107
|
+
objective?: {
|
|
3108
|
+
quality?: number | undefined;
|
|
3109
|
+
cost?: number | undefined;
|
|
3110
|
+
latency?: number | undefined;
|
|
3111
|
+
} | undefined;
|
|
3112
|
+
learning?: {
|
|
3113
|
+
minSamplesPerArm?: number | undefined;
|
|
3114
|
+
costRefUsd?: number | undefined;
|
|
3115
|
+
latencyRefMs?: number | undefined;
|
|
2139
3116
|
} | undefined;
|
|
2140
3117
|
} | undefined;
|
|
2141
3118
|
sub_agents?: Record<string, {
|
|
@@ -2154,20 +3131,45 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2154
3131
|
instructions: string;
|
|
2155
3132
|
model: string;
|
|
2156
3133
|
tools?: string[] | undefined;
|
|
3134
|
+
model_tiers?: {
|
|
3135
|
+
default: string;
|
|
3136
|
+
fast: string;
|
|
3137
|
+
routing?: {
|
|
3138
|
+
contextTokenThreshold?: number | undefined;
|
|
3139
|
+
toolsToDefault?: boolean | undefined;
|
|
3140
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3141
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3142
|
+
} | undefined;
|
|
3143
|
+
} | undefined;
|
|
2157
3144
|
model_fallbacks?: string[] | undefined;
|
|
2158
3145
|
circuit_breaker?: {
|
|
2159
3146
|
failureThreshold?: number | undefined;
|
|
2160
3147
|
windowMs?: number | undefined;
|
|
2161
3148
|
cooldownMs?: number | undefined;
|
|
2162
3149
|
} | undefined;
|
|
2163
|
-
|
|
2164
|
-
|
|
2165
|
-
|
|
3150
|
+
model_pool?: {
|
|
3151
|
+
candidates: {
|
|
3152
|
+
model: string;
|
|
3153
|
+
tags?: string[] | undefined;
|
|
3154
|
+
}[];
|
|
2166
3155
|
routing?: {
|
|
2167
3156
|
contextTokenThreshold?: number | undefined;
|
|
2168
3157
|
toolsToDefault?: boolean | undefined;
|
|
2169
3158
|
firstTurnToDefault?: boolean | undefined;
|
|
2170
3159
|
priorToolDensityThreshold?: number | undefined;
|
|
3160
|
+
strongTag?: string | undefined;
|
|
3161
|
+
cheapTag?: string | undefined;
|
|
3162
|
+
} | undefined;
|
|
3163
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
3164
|
+
objective?: {
|
|
3165
|
+
quality?: number | undefined;
|
|
3166
|
+
cost?: number | undefined;
|
|
3167
|
+
latency?: number | undefined;
|
|
3168
|
+
} | undefined;
|
|
3169
|
+
learning?: {
|
|
3170
|
+
minSamplesPerArm?: number | undefined;
|
|
3171
|
+
costRefUsd?: number | undefined;
|
|
3172
|
+
latencyRefMs?: number | undefined;
|
|
2171
3173
|
} | undefined;
|
|
2172
3174
|
} | undefined;
|
|
2173
3175
|
sub_agents?: Record<string, {
|
|
@@ -2767,20 +3769,45 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2767
3769
|
instructions: string;
|
|
2768
3770
|
model: string;
|
|
2769
3771
|
tools?: string[] | undefined;
|
|
3772
|
+
model_tiers?: {
|
|
3773
|
+
default: string;
|
|
3774
|
+
fast: string;
|
|
3775
|
+
routing?: {
|
|
3776
|
+
contextTokenThreshold?: number | undefined;
|
|
3777
|
+
toolsToDefault?: boolean | undefined;
|
|
3778
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3779
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3780
|
+
} | undefined;
|
|
3781
|
+
} | undefined;
|
|
2770
3782
|
model_fallbacks?: string[] | undefined;
|
|
2771
3783
|
circuit_breaker?: {
|
|
2772
3784
|
failureThreshold?: number | undefined;
|
|
2773
3785
|
windowMs?: number | undefined;
|
|
2774
3786
|
cooldownMs?: number | undefined;
|
|
2775
3787
|
} | undefined;
|
|
2776
|
-
|
|
2777
|
-
|
|
2778
|
-
|
|
3788
|
+
model_pool?: {
|
|
3789
|
+
candidates: {
|
|
3790
|
+
model: string;
|
|
3791
|
+
tags: string[];
|
|
3792
|
+
}[];
|
|
3793
|
+
policy: "static" | "heuristic" | "learned";
|
|
2779
3794
|
routing?: {
|
|
2780
3795
|
contextTokenThreshold?: number | undefined;
|
|
2781
3796
|
toolsToDefault?: boolean | undefined;
|
|
2782
3797
|
firstTurnToDefault?: boolean | undefined;
|
|
2783
3798
|
priorToolDensityThreshold?: number | undefined;
|
|
3799
|
+
strongTag?: string | undefined;
|
|
3800
|
+
cheapTag?: string | undefined;
|
|
3801
|
+
} | undefined;
|
|
3802
|
+
objective?: {
|
|
3803
|
+
quality?: number | undefined;
|
|
3804
|
+
cost?: number | undefined;
|
|
3805
|
+
latency?: number | undefined;
|
|
3806
|
+
} | undefined;
|
|
3807
|
+
learning?: {
|
|
3808
|
+
minSamplesPerArm?: number | undefined;
|
|
3809
|
+
costRefUsd?: number | undefined;
|
|
3810
|
+
latencyRefMs?: number | undefined;
|
|
2784
3811
|
} | undefined;
|
|
2785
3812
|
} | undefined;
|
|
2786
3813
|
sub_agents?: Record<string, {
|
|
@@ -2945,20 +3972,45 @@ declare const channelSchema: z.ZodObject<{
|
|
|
2945
3972
|
instructions: string;
|
|
2946
3973
|
model: string;
|
|
2947
3974
|
tools?: string[] | undefined;
|
|
3975
|
+
model_tiers?: {
|
|
3976
|
+
default: string;
|
|
3977
|
+
fast: string;
|
|
3978
|
+
routing?: {
|
|
3979
|
+
contextTokenThreshold?: number | undefined;
|
|
3980
|
+
toolsToDefault?: boolean | undefined;
|
|
3981
|
+
firstTurnToDefault?: boolean | undefined;
|
|
3982
|
+
priorToolDensityThreshold?: number | undefined;
|
|
3983
|
+
} | undefined;
|
|
3984
|
+
} | undefined;
|
|
2948
3985
|
model_fallbacks?: string[] | undefined;
|
|
2949
3986
|
circuit_breaker?: {
|
|
2950
3987
|
failureThreshold?: number | undefined;
|
|
2951
3988
|
windowMs?: number | undefined;
|
|
2952
3989
|
cooldownMs?: number | undefined;
|
|
2953
3990
|
} | undefined;
|
|
2954
|
-
|
|
2955
|
-
|
|
2956
|
-
|
|
3991
|
+
model_pool?: {
|
|
3992
|
+
candidates: {
|
|
3993
|
+
model: string;
|
|
3994
|
+
tags?: string[] | undefined;
|
|
3995
|
+
}[];
|
|
2957
3996
|
routing?: {
|
|
2958
3997
|
contextTokenThreshold?: number | undefined;
|
|
2959
3998
|
toolsToDefault?: boolean | undefined;
|
|
2960
3999
|
firstTurnToDefault?: boolean | undefined;
|
|
2961
4000
|
priorToolDensityThreshold?: number | undefined;
|
|
4001
|
+
strongTag?: string | undefined;
|
|
4002
|
+
cheapTag?: string | undefined;
|
|
4003
|
+
} | undefined;
|
|
4004
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
4005
|
+
objective?: {
|
|
4006
|
+
quality?: number | undefined;
|
|
4007
|
+
cost?: number | undefined;
|
|
4008
|
+
latency?: number | undefined;
|
|
4009
|
+
} | undefined;
|
|
4010
|
+
learning?: {
|
|
4011
|
+
minSamplesPerArm?: number | undefined;
|
|
4012
|
+
costRefUsd?: number | undefined;
|
|
4013
|
+
latencyRefMs?: number | undefined;
|
|
2962
4014
|
} | undefined;
|
|
2963
4015
|
} | undefined;
|
|
2964
4016
|
sub_agents?: Record<string, {
|
|
@@ -3564,7 +4616,7 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3564
4616
|
name: z.ZodString;
|
|
3565
4617
|
version: z.ZodOptional<z.ZodNumber>;
|
|
3566
4618
|
target: z.ZodLiteral<"managed">;
|
|
3567
|
-
agent: z.ZodObject<{
|
|
4619
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
3568
4620
|
model: z.ZodString;
|
|
3569
4621
|
instructions: z.ZodString;
|
|
3570
4622
|
model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -3622,15 +4674,162 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3622
4674
|
priorToolDensityThreshold?: number | undefined;
|
|
3623
4675
|
} | undefined;
|
|
3624
4676
|
}>>;
|
|
4677
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
4678
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
4679
|
+
model: z.ZodString;
|
|
4680
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
4681
|
+
}, "strict", z.ZodTypeAny, {
|
|
4682
|
+
model: string;
|
|
4683
|
+
tags: string[];
|
|
4684
|
+
}, {
|
|
4685
|
+
model: string;
|
|
4686
|
+
tags?: string[] | undefined;
|
|
4687
|
+
}>, "many">;
|
|
4688
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
4689
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
4690
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
4691
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
4692
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
4693
|
+
}, "strict", z.ZodTypeAny, {
|
|
4694
|
+
quality?: number | undefined;
|
|
4695
|
+
cost?: number | undefined;
|
|
4696
|
+
latency?: number | undefined;
|
|
4697
|
+
}, {
|
|
4698
|
+
quality?: number | undefined;
|
|
4699
|
+
cost?: number | undefined;
|
|
4700
|
+
latency?: number | undefined;
|
|
4701
|
+
}>>;
|
|
4702
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
4703
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
4704
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
4705
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
4706
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
4707
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
4708
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
4709
|
+
}, "strict", z.ZodTypeAny, {
|
|
4710
|
+
contextTokenThreshold?: number | undefined;
|
|
4711
|
+
toolsToDefault?: boolean | undefined;
|
|
4712
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4713
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4714
|
+
strongTag?: string | undefined;
|
|
4715
|
+
cheapTag?: string | undefined;
|
|
4716
|
+
}, {
|
|
4717
|
+
contextTokenThreshold?: number | undefined;
|
|
4718
|
+
toolsToDefault?: boolean | undefined;
|
|
4719
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4720
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4721
|
+
strongTag?: string | undefined;
|
|
4722
|
+
cheapTag?: string | undefined;
|
|
4723
|
+
}>>;
|
|
4724
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
4725
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
4726
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
4727
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
4728
|
+
}, "strict", z.ZodTypeAny, {
|
|
4729
|
+
minSamplesPerArm?: number | undefined;
|
|
4730
|
+
costRefUsd?: number | undefined;
|
|
4731
|
+
latencyRefMs?: number | undefined;
|
|
4732
|
+
}, {
|
|
4733
|
+
minSamplesPerArm?: number | undefined;
|
|
4734
|
+
costRefUsd?: number | undefined;
|
|
4735
|
+
latencyRefMs?: number | undefined;
|
|
4736
|
+
}>>;
|
|
4737
|
+
}, "strict", z.ZodTypeAny, {
|
|
4738
|
+
candidates: {
|
|
4739
|
+
model: string;
|
|
4740
|
+
tags: string[];
|
|
4741
|
+
}[];
|
|
4742
|
+
policy: "static" | "heuristic" | "learned";
|
|
4743
|
+
routing?: {
|
|
4744
|
+
contextTokenThreshold?: number | undefined;
|
|
4745
|
+
toolsToDefault?: boolean | undefined;
|
|
4746
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4747
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4748
|
+
strongTag?: string | undefined;
|
|
4749
|
+
cheapTag?: string | undefined;
|
|
4750
|
+
} | undefined;
|
|
4751
|
+
objective?: {
|
|
4752
|
+
quality?: number | undefined;
|
|
4753
|
+
cost?: number | undefined;
|
|
4754
|
+
latency?: number | undefined;
|
|
4755
|
+
} | undefined;
|
|
4756
|
+
learning?: {
|
|
4757
|
+
minSamplesPerArm?: number | undefined;
|
|
4758
|
+
costRefUsd?: number | undefined;
|
|
4759
|
+
latencyRefMs?: number | undefined;
|
|
4760
|
+
} | undefined;
|
|
4761
|
+
}, {
|
|
4762
|
+
candidates: {
|
|
4763
|
+
model: string;
|
|
4764
|
+
tags?: string[] | undefined;
|
|
4765
|
+
}[];
|
|
4766
|
+
routing?: {
|
|
4767
|
+
contextTokenThreshold?: number | undefined;
|
|
4768
|
+
toolsToDefault?: boolean | undefined;
|
|
4769
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4770
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4771
|
+
strongTag?: string | undefined;
|
|
4772
|
+
cheapTag?: string | undefined;
|
|
4773
|
+
} | undefined;
|
|
4774
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
4775
|
+
objective?: {
|
|
4776
|
+
quality?: number | undefined;
|
|
4777
|
+
cost?: number | undefined;
|
|
4778
|
+
latency?: number | undefined;
|
|
4779
|
+
} | undefined;
|
|
4780
|
+
learning?: {
|
|
4781
|
+
minSamplesPerArm?: number | undefined;
|
|
4782
|
+
costRefUsd?: number | undefined;
|
|
4783
|
+
latencyRefMs?: number | undefined;
|
|
4784
|
+
} | undefined;
|
|
4785
|
+
}>>;
|
|
3625
4786
|
}, "strict", z.ZodTypeAny, {
|
|
3626
4787
|
instructions: string;
|
|
3627
4788
|
model: string;
|
|
4789
|
+
model_tiers?: {
|
|
4790
|
+
default: string;
|
|
4791
|
+
fast: string;
|
|
4792
|
+
routing?: {
|
|
4793
|
+
contextTokenThreshold?: number | undefined;
|
|
4794
|
+
toolsToDefault?: boolean | undefined;
|
|
4795
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4796
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4797
|
+
} | undefined;
|
|
4798
|
+
} | undefined;
|
|
3628
4799
|
model_fallbacks?: string[] | undefined;
|
|
3629
4800
|
circuit_breaker?: {
|
|
3630
4801
|
failureThreshold?: number | undefined;
|
|
3631
4802
|
windowMs?: number | undefined;
|
|
3632
4803
|
cooldownMs?: number | undefined;
|
|
3633
4804
|
} | undefined;
|
|
4805
|
+
model_pool?: {
|
|
4806
|
+
candidates: {
|
|
4807
|
+
model: string;
|
|
4808
|
+
tags: string[];
|
|
4809
|
+
}[];
|
|
4810
|
+
policy: "static" | "heuristic" | "learned";
|
|
4811
|
+
routing?: {
|
|
4812
|
+
contextTokenThreshold?: number | undefined;
|
|
4813
|
+
toolsToDefault?: boolean | undefined;
|
|
4814
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4815
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4816
|
+
strongTag?: string | undefined;
|
|
4817
|
+
cheapTag?: string | undefined;
|
|
4818
|
+
} | undefined;
|
|
4819
|
+
objective?: {
|
|
4820
|
+
quality?: number | undefined;
|
|
4821
|
+
cost?: number | undefined;
|
|
4822
|
+
latency?: number | undefined;
|
|
4823
|
+
} | undefined;
|
|
4824
|
+
learning?: {
|
|
4825
|
+
minSamplesPerArm?: number | undefined;
|
|
4826
|
+
costRefUsd?: number | undefined;
|
|
4827
|
+
latencyRefMs?: number | undefined;
|
|
4828
|
+
} | undefined;
|
|
4829
|
+
} | undefined;
|
|
4830
|
+
}, {
|
|
4831
|
+
instructions: string;
|
|
4832
|
+
model: string;
|
|
3634
4833
|
model_tiers?: {
|
|
3635
4834
|
default: string;
|
|
3636
4835
|
fast: string;
|
|
@@ -3641,15 +4840,84 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3641
4840
|
priorToolDensityThreshold?: number | undefined;
|
|
3642
4841
|
} | undefined;
|
|
3643
4842
|
} | undefined;
|
|
3644
|
-
|
|
4843
|
+
model_fallbacks?: string[] | undefined;
|
|
4844
|
+
circuit_breaker?: {
|
|
4845
|
+
failureThreshold?: number | undefined;
|
|
4846
|
+
windowMs?: number | undefined;
|
|
4847
|
+
cooldownMs?: number | undefined;
|
|
4848
|
+
} | undefined;
|
|
4849
|
+
model_pool?: {
|
|
4850
|
+
candidates: {
|
|
4851
|
+
model: string;
|
|
4852
|
+
tags?: string[] | undefined;
|
|
4853
|
+
}[];
|
|
4854
|
+
routing?: {
|
|
4855
|
+
contextTokenThreshold?: number | undefined;
|
|
4856
|
+
toolsToDefault?: boolean | undefined;
|
|
4857
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4858
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4859
|
+
strongTag?: string | undefined;
|
|
4860
|
+
cheapTag?: string | undefined;
|
|
4861
|
+
} | undefined;
|
|
4862
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
4863
|
+
objective?: {
|
|
4864
|
+
quality?: number | undefined;
|
|
4865
|
+
cost?: number | undefined;
|
|
4866
|
+
latency?: number | undefined;
|
|
4867
|
+
} | undefined;
|
|
4868
|
+
learning?: {
|
|
4869
|
+
minSamplesPerArm?: number | undefined;
|
|
4870
|
+
costRefUsd?: number | undefined;
|
|
4871
|
+
latencyRefMs?: number | undefined;
|
|
4872
|
+
} | undefined;
|
|
4873
|
+
} | undefined;
|
|
4874
|
+
}>, {
|
|
3645
4875
|
instructions: string;
|
|
3646
4876
|
model: string;
|
|
4877
|
+
model_tiers?: {
|
|
4878
|
+
default: string;
|
|
4879
|
+
fast: string;
|
|
4880
|
+
routing?: {
|
|
4881
|
+
contextTokenThreshold?: number | undefined;
|
|
4882
|
+
toolsToDefault?: boolean | undefined;
|
|
4883
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4884
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4885
|
+
} | undefined;
|
|
4886
|
+
} | undefined;
|
|
3647
4887
|
model_fallbacks?: string[] | undefined;
|
|
3648
4888
|
circuit_breaker?: {
|
|
3649
4889
|
failureThreshold?: number | undefined;
|
|
3650
4890
|
windowMs?: number | undefined;
|
|
3651
4891
|
cooldownMs?: number | undefined;
|
|
3652
4892
|
} | undefined;
|
|
4893
|
+
model_pool?: {
|
|
4894
|
+
candidates: {
|
|
4895
|
+
model: string;
|
|
4896
|
+
tags: string[];
|
|
4897
|
+
}[];
|
|
4898
|
+
policy: "static" | "heuristic" | "learned";
|
|
4899
|
+
routing?: {
|
|
4900
|
+
contextTokenThreshold?: number | undefined;
|
|
4901
|
+
toolsToDefault?: boolean | undefined;
|
|
4902
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4903
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4904
|
+
strongTag?: string | undefined;
|
|
4905
|
+
cheapTag?: string | undefined;
|
|
4906
|
+
} | undefined;
|
|
4907
|
+
objective?: {
|
|
4908
|
+
quality?: number | undefined;
|
|
4909
|
+
cost?: number | undefined;
|
|
4910
|
+
latency?: number | undefined;
|
|
4911
|
+
} | undefined;
|
|
4912
|
+
learning?: {
|
|
4913
|
+
minSamplesPerArm?: number | undefined;
|
|
4914
|
+
costRefUsd?: number | undefined;
|
|
4915
|
+
latencyRefMs?: number | undefined;
|
|
4916
|
+
} | undefined;
|
|
4917
|
+
} | undefined;
|
|
4918
|
+
}, {
|
|
4919
|
+
instructions: string;
|
|
4920
|
+
model: string;
|
|
3653
4921
|
model_tiers?: {
|
|
3654
4922
|
default: string;
|
|
3655
4923
|
fast: string;
|
|
@@ -3660,6 +4928,37 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3660
4928
|
priorToolDensityThreshold?: number | undefined;
|
|
3661
4929
|
} | undefined;
|
|
3662
4930
|
} | undefined;
|
|
4931
|
+
model_fallbacks?: string[] | undefined;
|
|
4932
|
+
circuit_breaker?: {
|
|
4933
|
+
failureThreshold?: number | undefined;
|
|
4934
|
+
windowMs?: number | undefined;
|
|
4935
|
+
cooldownMs?: number | undefined;
|
|
4936
|
+
} | undefined;
|
|
4937
|
+
model_pool?: {
|
|
4938
|
+
candidates: {
|
|
4939
|
+
model: string;
|
|
4940
|
+
tags?: string[] | undefined;
|
|
4941
|
+
}[];
|
|
4942
|
+
routing?: {
|
|
4943
|
+
contextTokenThreshold?: number | undefined;
|
|
4944
|
+
toolsToDefault?: boolean | undefined;
|
|
4945
|
+
firstTurnToDefault?: boolean | undefined;
|
|
4946
|
+
priorToolDensityThreshold?: number | undefined;
|
|
4947
|
+
strongTag?: string | undefined;
|
|
4948
|
+
cheapTag?: string | undefined;
|
|
4949
|
+
} | undefined;
|
|
4950
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
4951
|
+
objective?: {
|
|
4952
|
+
quality?: number | undefined;
|
|
4953
|
+
cost?: number | undefined;
|
|
4954
|
+
latency?: number | undefined;
|
|
4955
|
+
} | undefined;
|
|
4956
|
+
learning?: {
|
|
4957
|
+
minSamplesPerArm?: number | undefined;
|
|
4958
|
+
costRefUsd?: number | undefined;
|
|
4959
|
+
latencyRefMs?: number | undefined;
|
|
4960
|
+
} | undefined;
|
|
4961
|
+
} | undefined;
|
|
3663
4962
|
}>;
|
|
3664
4963
|
tenants: z.ZodArray<z.ZodObject<{
|
|
3665
4964
|
id: z.ZodString;
|
|
@@ -3893,20 +5192,45 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3893
5192
|
agent: {
|
|
3894
5193
|
instructions: string;
|
|
3895
5194
|
model: string;
|
|
5195
|
+
model_tiers?: {
|
|
5196
|
+
default: string;
|
|
5197
|
+
fast: string;
|
|
5198
|
+
routing?: {
|
|
5199
|
+
contextTokenThreshold?: number | undefined;
|
|
5200
|
+
toolsToDefault?: boolean | undefined;
|
|
5201
|
+
firstTurnToDefault?: boolean | undefined;
|
|
5202
|
+
priorToolDensityThreshold?: number | undefined;
|
|
5203
|
+
} | undefined;
|
|
5204
|
+
} | undefined;
|
|
3896
5205
|
model_fallbacks?: string[] | undefined;
|
|
3897
5206
|
circuit_breaker?: {
|
|
3898
5207
|
failureThreshold?: number | undefined;
|
|
3899
5208
|
windowMs?: number | undefined;
|
|
3900
5209
|
cooldownMs?: number | undefined;
|
|
3901
5210
|
} | undefined;
|
|
3902
|
-
|
|
3903
|
-
|
|
3904
|
-
|
|
5211
|
+
model_pool?: {
|
|
5212
|
+
candidates: {
|
|
5213
|
+
model: string;
|
|
5214
|
+
tags: string[];
|
|
5215
|
+
}[];
|
|
5216
|
+
policy: "static" | "heuristic" | "learned";
|
|
3905
5217
|
routing?: {
|
|
3906
5218
|
contextTokenThreshold?: number | undefined;
|
|
3907
5219
|
toolsToDefault?: boolean | undefined;
|
|
3908
5220
|
firstTurnToDefault?: boolean | undefined;
|
|
3909
5221
|
priorToolDensityThreshold?: number | undefined;
|
|
5222
|
+
strongTag?: string | undefined;
|
|
5223
|
+
cheapTag?: string | undefined;
|
|
5224
|
+
} | undefined;
|
|
5225
|
+
objective?: {
|
|
5226
|
+
quality?: number | undefined;
|
|
5227
|
+
cost?: number | undefined;
|
|
5228
|
+
latency?: number | undefined;
|
|
5229
|
+
} | undefined;
|
|
5230
|
+
learning?: {
|
|
5231
|
+
minSamplesPerArm?: number | undefined;
|
|
5232
|
+
costRefUsd?: number | undefined;
|
|
5233
|
+
latencyRefMs?: number | undefined;
|
|
3910
5234
|
} | undefined;
|
|
3911
5235
|
} | undefined;
|
|
3912
5236
|
};
|
|
@@ -3970,20 +5294,45 @@ declare const managedSchema: z.ZodObject<{
|
|
|
3970
5294
|
agent: {
|
|
3971
5295
|
instructions: string;
|
|
3972
5296
|
model: string;
|
|
5297
|
+
model_tiers?: {
|
|
5298
|
+
default: string;
|
|
5299
|
+
fast: string;
|
|
5300
|
+
routing?: {
|
|
5301
|
+
contextTokenThreshold?: number | undefined;
|
|
5302
|
+
toolsToDefault?: boolean | undefined;
|
|
5303
|
+
firstTurnToDefault?: boolean | undefined;
|
|
5304
|
+
priorToolDensityThreshold?: number | undefined;
|
|
5305
|
+
} | undefined;
|
|
5306
|
+
} | undefined;
|
|
3973
5307
|
model_fallbacks?: string[] | undefined;
|
|
3974
5308
|
circuit_breaker?: {
|
|
3975
5309
|
failureThreshold?: number | undefined;
|
|
3976
5310
|
windowMs?: number | undefined;
|
|
3977
5311
|
cooldownMs?: number | undefined;
|
|
3978
5312
|
} | undefined;
|
|
3979
|
-
|
|
3980
|
-
|
|
3981
|
-
|
|
5313
|
+
model_pool?: {
|
|
5314
|
+
candidates: {
|
|
5315
|
+
model: string;
|
|
5316
|
+
tags?: string[] | undefined;
|
|
5317
|
+
}[];
|
|
3982
5318
|
routing?: {
|
|
3983
5319
|
contextTokenThreshold?: number | undefined;
|
|
3984
5320
|
toolsToDefault?: boolean | undefined;
|
|
3985
5321
|
firstTurnToDefault?: boolean | undefined;
|
|
3986
5322
|
priorToolDensityThreshold?: number | undefined;
|
|
5323
|
+
strongTag?: string | undefined;
|
|
5324
|
+
cheapTag?: string | undefined;
|
|
5325
|
+
} | undefined;
|
|
5326
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
5327
|
+
objective?: {
|
|
5328
|
+
quality?: number | undefined;
|
|
5329
|
+
cost?: number | undefined;
|
|
5330
|
+
latency?: number | undefined;
|
|
5331
|
+
} | undefined;
|
|
5332
|
+
learning?: {
|
|
5333
|
+
minSamplesPerArm?: number | undefined;
|
|
5334
|
+
costRefUsd?: number | undefined;
|
|
5335
|
+
latencyRefMs?: number | undefined;
|
|
3987
5336
|
} | undefined;
|
|
3988
5337
|
} | undefined;
|
|
3989
5338
|
};
|
|
@@ -7058,9 +8407,9 @@ declare const onchainGameSchema: z.ZodObject<{
|
|
|
7058
8407
|
};
|
|
7059
8408
|
stateReader: string;
|
|
7060
8409
|
turnSemantics: "turn-based" | "real-time" | "async";
|
|
8410
|
+
objective?: string | undefined;
|
|
7061
8411
|
actionsContract?: string | undefined;
|
|
7062
8412
|
moveTimeoutMs?: number | undefined;
|
|
7063
|
-
objective?: string | undefined;
|
|
7064
8413
|
}, {
|
|
7065
8414
|
contract: {
|
|
7066
8415
|
id: string;
|
|
@@ -7069,10 +8418,10 @@ declare const onchainGameSchema: z.ZodObject<{
|
|
|
7069
8418
|
abiRef: string;
|
|
7070
8419
|
};
|
|
7071
8420
|
stateReader: string;
|
|
8421
|
+
objective?: string | undefined;
|
|
7072
8422
|
actionsContract?: string | undefined;
|
|
7073
8423
|
turnSemantics?: "turn-based" | "real-time" | "async" | undefined;
|
|
7074
8424
|
moveTimeoutMs?: number | undefined;
|
|
7075
|
-
objective?: string | undefined;
|
|
7076
8425
|
}>;
|
|
7077
8426
|
transaction_policy: z.ZodDefault<z.ZodObject<{
|
|
7078
8427
|
defaultWriteApproval: z.ZodDefault<z.ZodEnum<["required", "policy", "none"]>>;
|
|
@@ -7237,9 +8586,9 @@ declare const onchainGameSchema: z.ZodObject<{
|
|
|
7237
8586
|
};
|
|
7238
8587
|
stateReader: string;
|
|
7239
8588
|
turnSemantics: "turn-based" | "real-time" | "async";
|
|
8589
|
+
objective?: string | undefined;
|
|
7240
8590
|
actionsContract?: string | undefined;
|
|
7241
8591
|
moveTimeoutMs?: number | undefined;
|
|
7242
|
-
objective?: string | undefined;
|
|
7243
8592
|
};
|
|
7244
8593
|
tools?: string[] | undefined;
|
|
7245
8594
|
permissions?: {
|
|
@@ -7310,10 +8659,10 @@ declare const onchainGameSchema: z.ZodObject<{
|
|
|
7310
8659
|
abiRef: string;
|
|
7311
8660
|
};
|
|
7312
8661
|
stateReader: string;
|
|
8662
|
+
objective?: string | undefined;
|
|
7313
8663
|
actionsContract?: string | undefined;
|
|
7314
8664
|
turnSemantics?: "turn-based" | "real-time" | "async" | undefined;
|
|
7315
8665
|
moveTimeoutMs?: number | undefined;
|
|
7316
|
-
objective?: string | undefined;
|
|
7317
8666
|
};
|
|
7318
8667
|
tools?: string[] | undefined;
|
|
7319
8668
|
permissions?: {
|
|
@@ -7359,7 +8708,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7359
8708
|
name: z.ZodString;
|
|
7360
8709
|
version: z.ZodOptional<z.ZodNumber>;
|
|
7361
8710
|
target: z.ZodLiteral<"cli">;
|
|
7362
|
-
agent: z.ZodObject<{
|
|
8711
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
7363
8712
|
model: z.ZodString;
|
|
7364
8713
|
instructions: z.ZodString;
|
|
7365
8714
|
max_tokens: z.ZodOptional<z.ZodNumber>;
|
|
@@ -7380,42 +8729,151 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7380
8729
|
windowMs?: number | undefined;
|
|
7381
8730
|
cooldownMs?: number | undefined;
|
|
7382
8731
|
}>>;
|
|
7383
|
-
model_tiers: z.ZodOptional<z.ZodObject<{
|
|
7384
|
-
fast: z.ZodString;
|
|
7385
|
-
default: z.ZodString;
|
|
8732
|
+
model_tiers: z.ZodOptional<z.ZodObject<{
|
|
8733
|
+
fast: z.ZodString;
|
|
8734
|
+
default: z.ZodString;
|
|
8735
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
8736
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
8737
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
8738
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
8739
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
8740
|
+
}, "strict", z.ZodTypeAny, {
|
|
8741
|
+
contextTokenThreshold?: number | undefined;
|
|
8742
|
+
toolsToDefault?: boolean | undefined;
|
|
8743
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8744
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8745
|
+
}, {
|
|
8746
|
+
contextTokenThreshold?: number | undefined;
|
|
8747
|
+
toolsToDefault?: boolean | undefined;
|
|
8748
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8749
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8750
|
+
}>>;
|
|
8751
|
+
}, "strict", z.ZodTypeAny, {
|
|
8752
|
+
default: string;
|
|
8753
|
+
fast: string;
|
|
8754
|
+
routing?: {
|
|
8755
|
+
contextTokenThreshold?: number | undefined;
|
|
8756
|
+
toolsToDefault?: boolean | undefined;
|
|
8757
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8758
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8759
|
+
} | undefined;
|
|
8760
|
+
}, {
|
|
8761
|
+
default: string;
|
|
8762
|
+
fast: string;
|
|
8763
|
+
routing?: {
|
|
8764
|
+
contextTokenThreshold?: number | undefined;
|
|
8765
|
+
toolsToDefault?: boolean | undefined;
|
|
8766
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8767
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8768
|
+
} | undefined;
|
|
8769
|
+
}>>;
|
|
8770
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
8771
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
8772
|
+
model: z.ZodString;
|
|
8773
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
8774
|
+
}, "strict", z.ZodTypeAny, {
|
|
8775
|
+
model: string;
|
|
8776
|
+
tags: string[];
|
|
8777
|
+
}, {
|
|
8778
|
+
model: string;
|
|
8779
|
+
tags?: string[] | undefined;
|
|
8780
|
+
}>, "many">;
|
|
8781
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
8782
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
8783
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
8784
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
8785
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
8786
|
+
}, "strict", z.ZodTypeAny, {
|
|
8787
|
+
quality?: number | undefined;
|
|
8788
|
+
cost?: number | undefined;
|
|
8789
|
+
latency?: number | undefined;
|
|
8790
|
+
}, {
|
|
8791
|
+
quality?: number | undefined;
|
|
8792
|
+
cost?: number | undefined;
|
|
8793
|
+
latency?: number | undefined;
|
|
8794
|
+
}>>;
|
|
7386
8795
|
routing: z.ZodOptional<z.ZodObject<{
|
|
7387
8796
|
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
7388
8797
|
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
7389
8798
|
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
7390
8799
|
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
8800
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
8801
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
7391
8802
|
}, "strict", z.ZodTypeAny, {
|
|
7392
8803
|
contextTokenThreshold?: number | undefined;
|
|
7393
8804
|
toolsToDefault?: boolean | undefined;
|
|
7394
8805
|
firstTurnToDefault?: boolean | undefined;
|
|
7395
8806
|
priorToolDensityThreshold?: number | undefined;
|
|
8807
|
+
strongTag?: string | undefined;
|
|
8808
|
+
cheapTag?: string | undefined;
|
|
7396
8809
|
}, {
|
|
7397
8810
|
contextTokenThreshold?: number | undefined;
|
|
7398
8811
|
toolsToDefault?: boolean | undefined;
|
|
7399
8812
|
firstTurnToDefault?: boolean | undefined;
|
|
7400
8813
|
priorToolDensityThreshold?: number | undefined;
|
|
8814
|
+
strongTag?: string | undefined;
|
|
8815
|
+
cheapTag?: string | undefined;
|
|
8816
|
+
}>>;
|
|
8817
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
8818
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
8819
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
8820
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
8821
|
+
}, "strict", z.ZodTypeAny, {
|
|
8822
|
+
minSamplesPerArm?: number | undefined;
|
|
8823
|
+
costRefUsd?: number | undefined;
|
|
8824
|
+
latencyRefMs?: number | undefined;
|
|
8825
|
+
}, {
|
|
8826
|
+
minSamplesPerArm?: number | undefined;
|
|
8827
|
+
costRefUsd?: number | undefined;
|
|
8828
|
+
latencyRefMs?: number | undefined;
|
|
7401
8829
|
}>>;
|
|
7402
8830
|
}, "strict", z.ZodTypeAny, {
|
|
7403
|
-
|
|
7404
|
-
|
|
8831
|
+
candidates: {
|
|
8832
|
+
model: string;
|
|
8833
|
+
tags: string[];
|
|
8834
|
+
}[];
|
|
8835
|
+
policy: "static" | "heuristic" | "learned";
|
|
7405
8836
|
routing?: {
|
|
7406
8837
|
contextTokenThreshold?: number | undefined;
|
|
7407
8838
|
toolsToDefault?: boolean | undefined;
|
|
7408
8839
|
firstTurnToDefault?: boolean | undefined;
|
|
7409
8840
|
priorToolDensityThreshold?: number | undefined;
|
|
8841
|
+
strongTag?: string | undefined;
|
|
8842
|
+
cheapTag?: string | undefined;
|
|
8843
|
+
} | undefined;
|
|
8844
|
+
objective?: {
|
|
8845
|
+
quality?: number | undefined;
|
|
8846
|
+
cost?: number | undefined;
|
|
8847
|
+
latency?: number | undefined;
|
|
8848
|
+
} | undefined;
|
|
8849
|
+
learning?: {
|
|
8850
|
+
minSamplesPerArm?: number | undefined;
|
|
8851
|
+
costRefUsd?: number | undefined;
|
|
8852
|
+
latencyRefMs?: number | undefined;
|
|
7410
8853
|
} | undefined;
|
|
7411
8854
|
}, {
|
|
7412
|
-
|
|
7413
|
-
|
|
8855
|
+
candidates: {
|
|
8856
|
+
model: string;
|
|
8857
|
+
tags?: string[] | undefined;
|
|
8858
|
+
}[];
|
|
7414
8859
|
routing?: {
|
|
7415
8860
|
contextTokenThreshold?: number | undefined;
|
|
7416
8861
|
toolsToDefault?: boolean | undefined;
|
|
7417
8862
|
firstTurnToDefault?: boolean | undefined;
|
|
7418
8863
|
priorToolDensityThreshold?: number | undefined;
|
|
8864
|
+
strongTag?: string | undefined;
|
|
8865
|
+
cheapTag?: string | undefined;
|
|
8866
|
+
} | undefined;
|
|
8867
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
8868
|
+
objective?: {
|
|
8869
|
+
quality?: number | undefined;
|
|
8870
|
+
cost?: number | undefined;
|
|
8871
|
+
latency?: number | undefined;
|
|
8872
|
+
} | undefined;
|
|
8873
|
+
learning?: {
|
|
8874
|
+
minSamplesPerArm?: number | undefined;
|
|
8875
|
+
costRefUsd?: number | undefined;
|
|
8876
|
+
latencyRefMs?: number | undefined;
|
|
7419
8877
|
} | undefined;
|
|
7420
8878
|
}>>;
|
|
7421
8879
|
sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -7458,13 +8916,62 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7458
8916
|
}, "strict", z.ZodTypeAny, {
|
|
7459
8917
|
instructions: string;
|
|
7460
8918
|
model: string;
|
|
7461
|
-
|
|
8919
|
+
model_tiers?: {
|
|
8920
|
+
default: string;
|
|
8921
|
+
fast: string;
|
|
8922
|
+
routing?: {
|
|
8923
|
+
contextTokenThreshold?: number | undefined;
|
|
8924
|
+
toolsToDefault?: boolean | undefined;
|
|
8925
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8926
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8927
|
+
} | undefined;
|
|
8928
|
+
} | undefined;
|
|
7462
8929
|
model_fallbacks?: string[] | undefined;
|
|
8930
|
+
max_tokens?: number | undefined;
|
|
7463
8931
|
circuit_breaker?: {
|
|
7464
8932
|
failureThreshold?: number | undefined;
|
|
7465
8933
|
windowMs?: number | undefined;
|
|
7466
8934
|
cooldownMs?: number | undefined;
|
|
7467
8935
|
} | undefined;
|
|
8936
|
+
model_pool?: {
|
|
8937
|
+
candidates: {
|
|
8938
|
+
model: string;
|
|
8939
|
+
tags: string[];
|
|
8940
|
+
}[];
|
|
8941
|
+
policy: "static" | "heuristic" | "learned";
|
|
8942
|
+
routing?: {
|
|
8943
|
+
contextTokenThreshold?: number | undefined;
|
|
8944
|
+
toolsToDefault?: boolean | undefined;
|
|
8945
|
+
firstTurnToDefault?: boolean | undefined;
|
|
8946
|
+
priorToolDensityThreshold?: number | undefined;
|
|
8947
|
+
strongTag?: string | undefined;
|
|
8948
|
+
cheapTag?: string | undefined;
|
|
8949
|
+
} | undefined;
|
|
8950
|
+
objective?: {
|
|
8951
|
+
quality?: number | undefined;
|
|
8952
|
+
cost?: number | undefined;
|
|
8953
|
+
latency?: number | undefined;
|
|
8954
|
+
} | undefined;
|
|
8955
|
+
learning?: {
|
|
8956
|
+
minSamplesPerArm?: number | undefined;
|
|
8957
|
+
costRefUsd?: number | undefined;
|
|
8958
|
+
latencyRefMs?: number | undefined;
|
|
8959
|
+
} | undefined;
|
|
8960
|
+
} | undefined;
|
|
8961
|
+
sub_agents?: Record<string, {
|
|
8962
|
+
description: string;
|
|
8963
|
+
instructions: string;
|
|
8964
|
+
tools?: string[] | undefined;
|
|
8965
|
+
model?: string | undefined;
|
|
8966
|
+
permissions?: "inherit" | "scoped" | {
|
|
8967
|
+
allow: string[];
|
|
8968
|
+
deny: string[];
|
|
8969
|
+
} | undefined;
|
|
8970
|
+
inherit_bypass?: boolean | undefined;
|
|
8971
|
+
}> | undefined;
|
|
8972
|
+
}, {
|
|
8973
|
+
instructions: string;
|
|
8974
|
+
model: string;
|
|
7468
8975
|
model_tiers?: {
|
|
7469
8976
|
default: string;
|
|
7470
8977
|
fast: string;
|
|
@@ -7475,6 +8982,38 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7475
8982
|
priorToolDensityThreshold?: number | undefined;
|
|
7476
8983
|
} | undefined;
|
|
7477
8984
|
} | undefined;
|
|
8985
|
+
model_fallbacks?: string[] | undefined;
|
|
8986
|
+
max_tokens?: number | undefined;
|
|
8987
|
+
circuit_breaker?: {
|
|
8988
|
+
failureThreshold?: number | undefined;
|
|
8989
|
+
windowMs?: number | undefined;
|
|
8990
|
+
cooldownMs?: number | undefined;
|
|
8991
|
+
} | undefined;
|
|
8992
|
+
model_pool?: {
|
|
8993
|
+
candidates: {
|
|
8994
|
+
model: string;
|
|
8995
|
+
tags?: string[] | undefined;
|
|
8996
|
+
}[];
|
|
8997
|
+
routing?: {
|
|
8998
|
+
contextTokenThreshold?: number | undefined;
|
|
8999
|
+
toolsToDefault?: boolean | undefined;
|
|
9000
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9001
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9002
|
+
strongTag?: string | undefined;
|
|
9003
|
+
cheapTag?: string | undefined;
|
|
9004
|
+
} | undefined;
|
|
9005
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
9006
|
+
objective?: {
|
|
9007
|
+
quality?: number | undefined;
|
|
9008
|
+
cost?: number | undefined;
|
|
9009
|
+
latency?: number | undefined;
|
|
9010
|
+
} | undefined;
|
|
9011
|
+
learning?: {
|
|
9012
|
+
minSamplesPerArm?: number | undefined;
|
|
9013
|
+
costRefUsd?: number | undefined;
|
|
9014
|
+
latencyRefMs?: number | undefined;
|
|
9015
|
+
} | undefined;
|
|
9016
|
+
} | undefined;
|
|
7478
9017
|
sub_agents?: Record<string, {
|
|
7479
9018
|
description: string;
|
|
7480
9019
|
instructions: string;
|
|
@@ -7486,16 +9025,65 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7486
9025
|
} | undefined;
|
|
7487
9026
|
inherit_bypass?: boolean | undefined;
|
|
7488
9027
|
}> | undefined;
|
|
7489
|
-
}
|
|
9028
|
+
}>, {
|
|
7490
9029
|
instructions: string;
|
|
7491
9030
|
model: string;
|
|
7492
|
-
|
|
9031
|
+
model_tiers?: {
|
|
9032
|
+
default: string;
|
|
9033
|
+
fast: string;
|
|
9034
|
+
routing?: {
|
|
9035
|
+
contextTokenThreshold?: number | undefined;
|
|
9036
|
+
toolsToDefault?: boolean | undefined;
|
|
9037
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9038
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9039
|
+
} | undefined;
|
|
9040
|
+
} | undefined;
|
|
7493
9041
|
model_fallbacks?: string[] | undefined;
|
|
9042
|
+
max_tokens?: number | undefined;
|
|
7494
9043
|
circuit_breaker?: {
|
|
7495
9044
|
failureThreshold?: number | undefined;
|
|
7496
9045
|
windowMs?: number | undefined;
|
|
7497
9046
|
cooldownMs?: number | undefined;
|
|
7498
9047
|
} | undefined;
|
|
9048
|
+
model_pool?: {
|
|
9049
|
+
candidates: {
|
|
9050
|
+
model: string;
|
|
9051
|
+
tags: string[];
|
|
9052
|
+
}[];
|
|
9053
|
+
policy: "static" | "heuristic" | "learned";
|
|
9054
|
+
routing?: {
|
|
9055
|
+
contextTokenThreshold?: number | undefined;
|
|
9056
|
+
toolsToDefault?: boolean | undefined;
|
|
9057
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9058
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9059
|
+
strongTag?: string | undefined;
|
|
9060
|
+
cheapTag?: string | undefined;
|
|
9061
|
+
} | undefined;
|
|
9062
|
+
objective?: {
|
|
9063
|
+
quality?: number | undefined;
|
|
9064
|
+
cost?: number | undefined;
|
|
9065
|
+
latency?: number | undefined;
|
|
9066
|
+
} | undefined;
|
|
9067
|
+
learning?: {
|
|
9068
|
+
minSamplesPerArm?: number | undefined;
|
|
9069
|
+
costRefUsd?: number | undefined;
|
|
9070
|
+
latencyRefMs?: number | undefined;
|
|
9071
|
+
} | undefined;
|
|
9072
|
+
} | undefined;
|
|
9073
|
+
sub_agents?: Record<string, {
|
|
9074
|
+
description: string;
|
|
9075
|
+
instructions: string;
|
|
9076
|
+
tools?: string[] | undefined;
|
|
9077
|
+
model?: string | undefined;
|
|
9078
|
+
permissions?: "inherit" | "scoped" | {
|
|
9079
|
+
allow: string[];
|
|
9080
|
+
deny: string[];
|
|
9081
|
+
} | undefined;
|
|
9082
|
+
inherit_bypass?: boolean | undefined;
|
|
9083
|
+
}> | undefined;
|
|
9084
|
+
}, {
|
|
9085
|
+
instructions: string;
|
|
9086
|
+
model: string;
|
|
7499
9087
|
model_tiers?: {
|
|
7500
9088
|
default: string;
|
|
7501
9089
|
fast: string;
|
|
@@ -7506,6 +9094,38 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7506
9094
|
priorToolDensityThreshold?: number | undefined;
|
|
7507
9095
|
} | undefined;
|
|
7508
9096
|
} | undefined;
|
|
9097
|
+
model_fallbacks?: string[] | undefined;
|
|
9098
|
+
max_tokens?: number | undefined;
|
|
9099
|
+
circuit_breaker?: {
|
|
9100
|
+
failureThreshold?: number | undefined;
|
|
9101
|
+
windowMs?: number | undefined;
|
|
9102
|
+
cooldownMs?: number | undefined;
|
|
9103
|
+
} | undefined;
|
|
9104
|
+
model_pool?: {
|
|
9105
|
+
candidates: {
|
|
9106
|
+
model: string;
|
|
9107
|
+
tags?: string[] | undefined;
|
|
9108
|
+
}[];
|
|
9109
|
+
routing?: {
|
|
9110
|
+
contextTokenThreshold?: number | undefined;
|
|
9111
|
+
toolsToDefault?: boolean | undefined;
|
|
9112
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9113
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9114
|
+
strongTag?: string | undefined;
|
|
9115
|
+
cheapTag?: string | undefined;
|
|
9116
|
+
} | undefined;
|
|
9117
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
9118
|
+
objective?: {
|
|
9119
|
+
quality?: number | undefined;
|
|
9120
|
+
cost?: number | undefined;
|
|
9121
|
+
latency?: number | undefined;
|
|
9122
|
+
} | undefined;
|
|
9123
|
+
learning?: {
|
|
9124
|
+
minSamplesPerArm?: number | undefined;
|
|
9125
|
+
costRefUsd?: number | undefined;
|
|
9126
|
+
latencyRefMs?: number | undefined;
|
|
9127
|
+
} | undefined;
|
|
9128
|
+
} | undefined;
|
|
7509
9129
|
sub_agents?: Record<string, {
|
|
7510
9130
|
description: string;
|
|
7511
9131
|
instructions: string;
|
|
@@ -7998,21 +9618,46 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
7998
9618
|
agent: {
|
|
7999
9619
|
instructions: string;
|
|
8000
9620
|
model: string;
|
|
8001
|
-
|
|
9621
|
+
model_tiers?: {
|
|
9622
|
+
default: string;
|
|
9623
|
+
fast: string;
|
|
9624
|
+
routing?: {
|
|
9625
|
+
contextTokenThreshold?: number | undefined;
|
|
9626
|
+
toolsToDefault?: boolean | undefined;
|
|
9627
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9628
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9629
|
+
} | undefined;
|
|
9630
|
+
} | undefined;
|
|
8002
9631
|
model_fallbacks?: string[] | undefined;
|
|
9632
|
+
max_tokens?: number | undefined;
|
|
8003
9633
|
circuit_breaker?: {
|
|
8004
9634
|
failureThreshold?: number | undefined;
|
|
8005
9635
|
windowMs?: number | undefined;
|
|
8006
9636
|
cooldownMs?: number | undefined;
|
|
8007
9637
|
} | undefined;
|
|
8008
|
-
|
|
8009
|
-
|
|
8010
|
-
|
|
9638
|
+
model_pool?: {
|
|
9639
|
+
candidates: {
|
|
9640
|
+
model: string;
|
|
9641
|
+
tags: string[];
|
|
9642
|
+
}[];
|
|
9643
|
+
policy: "static" | "heuristic" | "learned";
|
|
8011
9644
|
routing?: {
|
|
8012
9645
|
contextTokenThreshold?: number | undefined;
|
|
8013
9646
|
toolsToDefault?: boolean | undefined;
|
|
8014
9647
|
firstTurnToDefault?: boolean | undefined;
|
|
8015
9648
|
priorToolDensityThreshold?: number | undefined;
|
|
9649
|
+
strongTag?: string | undefined;
|
|
9650
|
+
cheapTag?: string | undefined;
|
|
9651
|
+
} | undefined;
|
|
9652
|
+
objective?: {
|
|
9653
|
+
quality?: number | undefined;
|
|
9654
|
+
cost?: number | undefined;
|
|
9655
|
+
latency?: number | undefined;
|
|
9656
|
+
} | undefined;
|
|
9657
|
+
learning?: {
|
|
9658
|
+
minSamplesPerArm?: number | undefined;
|
|
9659
|
+
costRefUsd?: number | undefined;
|
|
9660
|
+
latencyRefMs?: number | undefined;
|
|
8016
9661
|
} | undefined;
|
|
8017
9662
|
} | undefined;
|
|
8018
9663
|
sub_agents?: Record<string, {
|
|
@@ -8155,21 +9800,46 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8155
9800
|
agent: {
|
|
8156
9801
|
instructions: string;
|
|
8157
9802
|
model: string;
|
|
8158
|
-
|
|
9803
|
+
model_tiers?: {
|
|
9804
|
+
default: string;
|
|
9805
|
+
fast: string;
|
|
9806
|
+
routing?: {
|
|
9807
|
+
contextTokenThreshold?: number | undefined;
|
|
9808
|
+
toolsToDefault?: boolean | undefined;
|
|
9809
|
+
firstTurnToDefault?: boolean | undefined;
|
|
9810
|
+
priorToolDensityThreshold?: number | undefined;
|
|
9811
|
+
} | undefined;
|
|
9812
|
+
} | undefined;
|
|
8159
9813
|
model_fallbacks?: string[] | undefined;
|
|
9814
|
+
max_tokens?: number | undefined;
|
|
8160
9815
|
circuit_breaker?: {
|
|
8161
9816
|
failureThreshold?: number | undefined;
|
|
8162
9817
|
windowMs?: number | undefined;
|
|
8163
9818
|
cooldownMs?: number | undefined;
|
|
8164
9819
|
} | undefined;
|
|
8165
|
-
|
|
8166
|
-
|
|
8167
|
-
|
|
9820
|
+
model_pool?: {
|
|
9821
|
+
candidates: {
|
|
9822
|
+
model: string;
|
|
9823
|
+
tags?: string[] | undefined;
|
|
9824
|
+
}[];
|
|
8168
9825
|
routing?: {
|
|
8169
9826
|
contextTokenThreshold?: number | undefined;
|
|
8170
9827
|
toolsToDefault?: boolean | undefined;
|
|
8171
9828
|
firstTurnToDefault?: boolean | undefined;
|
|
8172
9829
|
priorToolDensityThreshold?: number | undefined;
|
|
9830
|
+
strongTag?: string | undefined;
|
|
9831
|
+
cheapTag?: string | undefined;
|
|
9832
|
+
} | undefined;
|
|
9833
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
9834
|
+
objective?: {
|
|
9835
|
+
quality?: number | undefined;
|
|
9836
|
+
cost?: number | undefined;
|
|
9837
|
+
latency?: number | undefined;
|
|
9838
|
+
} | undefined;
|
|
9839
|
+
learning?: {
|
|
9840
|
+
minSamplesPerArm?: number | undefined;
|
|
9841
|
+
costRefUsd?: number | undefined;
|
|
9842
|
+
latencyRefMs?: number | undefined;
|
|
8173
9843
|
} | undefined;
|
|
8174
9844
|
} | undefined;
|
|
8175
9845
|
sub_agents?: Record<string, {
|
|
@@ -8694,7 +10364,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8694
10364
|
name: z.ZodString;
|
|
8695
10365
|
version: z.ZodOptional<z.ZodNumber>;
|
|
8696
10366
|
target: z.ZodLiteral<"channel">;
|
|
8697
|
-
agent: z.ZodObject<{
|
|
10367
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
8698
10368
|
model: z.ZodString;
|
|
8699
10369
|
instructions: z.ZodString;
|
|
8700
10370
|
model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -8752,6 +10422,115 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8752
10422
|
priorToolDensityThreshold?: number | undefined;
|
|
8753
10423
|
} | undefined;
|
|
8754
10424
|
}>>;
|
|
10425
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
10426
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
10427
|
+
model: z.ZodString;
|
|
10428
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
10429
|
+
}, "strict", z.ZodTypeAny, {
|
|
10430
|
+
model: string;
|
|
10431
|
+
tags: string[];
|
|
10432
|
+
}, {
|
|
10433
|
+
model: string;
|
|
10434
|
+
tags?: string[] | undefined;
|
|
10435
|
+
}>, "many">;
|
|
10436
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
10437
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
10438
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
10439
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
10440
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
10441
|
+
}, "strict", z.ZodTypeAny, {
|
|
10442
|
+
quality?: number | undefined;
|
|
10443
|
+
cost?: number | undefined;
|
|
10444
|
+
latency?: number | undefined;
|
|
10445
|
+
}, {
|
|
10446
|
+
quality?: number | undefined;
|
|
10447
|
+
cost?: number | undefined;
|
|
10448
|
+
latency?: number | undefined;
|
|
10449
|
+
}>>;
|
|
10450
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
10451
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
10452
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
10453
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
10454
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
10455
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
10456
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
10457
|
+
}, "strict", z.ZodTypeAny, {
|
|
10458
|
+
contextTokenThreshold?: number | undefined;
|
|
10459
|
+
toolsToDefault?: boolean | undefined;
|
|
10460
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10461
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10462
|
+
strongTag?: string | undefined;
|
|
10463
|
+
cheapTag?: string | undefined;
|
|
10464
|
+
}, {
|
|
10465
|
+
contextTokenThreshold?: number | undefined;
|
|
10466
|
+
toolsToDefault?: boolean | undefined;
|
|
10467
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10468
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10469
|
+
strongTag?: string | undefined;
|
|
10470
|
+
cheapTag?: string | undefined;
|
|
10471
|
+
}>>;
|
|
10472
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
10473
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
10474
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
10475
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
10476
|
+
}, "strict", z.ZodTypeAny, {
|
|
10477
|
+
minSamplesPerArm?: number | undefined;
|
|
10478
|
+
costRefUsd?: number | undefined;
|
|
10479
|
+
latencyRefMs?: number | undefined;
|
|
10480
|
+
}, {
|
|
10481
|
+
minSamplesPerArm?: number | undefined;
|
|
10482
|
+
costRefUsd?: number | undefined;
|
|
10483
|
+
latencyRefMs?: number | undefined;
|
|
10484
|
+
}>>;
|
|
10485
|
+
}, "strict", z.ZodTypeAny, {
|
|
10486
|
+
candidates: {
|
|
10487
|
+
model: string;
|
|
10488
|
+
tags: string[];
|
|
10489
|
+
}[];
|
|
10490
|
+
policy: "static" | "heuristic" | "learned";
|
|
10491
|
+
routing?: {
|
|
10492
|
+
contextTokenThreshold?: number | undefined;
|
|
10493
|
+
toolsToDefault?: boolean | undefined;
|
|
10494
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10495
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10496
|
+
strongTag?: string | undefined;
|
|
10497
|
+
cheapTag?: string | undefined;
|
|
10498
|
+
} | undefined;
|
|
10499
|
+
objective?: {
|
|
10500
|
+
quality?: number | undefined;
|
|
10501
|
+
cost?: number | undefined;
|
|
10502
|
+
latency?: number | undefined;
|
|
10503
|
+
} | undefined;
|
|
10504
|
+
learning?: {
|
|
10505
|
+
minSamplesPerArm?: number | undefined;
|
|
10506
|
+
costRefUsd?: number | undefined;
|
|
10507
|
+
latencyRefMs?: number | undefined;
|
|
10508
|
+
} | undefined;
|
|
10509
|
+
}, {
|
|
10510
|
+
candidates: {
|
|
10511
|
+
model: string;
|
|
10512
|
+
tags?: string[] | undefined;
|
|
10513
|
+
}[];
|
|
10514
|
+
routing?: {
|
|
10515
|
+
contextTokenThreshold?: number | undefined;
|
|
10516
|
+
toolsToDefault?: boolean | undefined;
|
|
10517
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10518
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10519
|
+
strongTag?: string | undefined;
|
|
10520
|
+
cheapTag?: string | undefined;
|
|
10521
|
+
} | undefined;
|
|
10522
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
10523
|
+
objective?: {
|
|
10524
|
+
quality?: number | undefined;
|
|
10525
|
+
cost?: number | undefined;
|
|
10526
|
+
latency?: number | undefined;
|
|
10527
|
+
} | undefined;
|
|
10528
|
+
learning?: {
|
|
10529
|
+
minSamplesPerArm?: number | undefined;
|
|
10530
|
+
costRefUsd?: number | undefined;
|
|
10531
|
+
latencyRefMs?: number | undefined;
|
|
10532
|
+
} | undefined;
|
|
10533
|
+
}>>;
|
|
8755
10534
|
tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
8756
10535
|
tool_config: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
|
|
8757
10536
|
sub_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -8780,7 +10559,120 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8780
10559
|
deny: string[];
|
|
8781
10560
|
} | undefined;
|
|
8782
10561
|
inherit_bypass?: boolean | undefined;
|
|
8783
|
-
}, {
|
|
10562
|
+
}, {
|
|
10563
|
+
description: string;
|
|
10564
|
+
instructions: string;
|
|
10565
|
+
tools?: string[] | undefined;
|
|
10566
|
+
model?: string | undefined;
|
|
10567
|
+
permissions?: "inherit" | "scoped" | {
|
|
10568
|
+
allow: string[];
|
|
10569
|
+
deny: string[];
|
|
10570
|
+
} | undefined;
|
|
10571
|
+
inherit_bypass?: boolean | undefined;
|
|
10572
|
+
}>>>;
|
|
10573
|
+
}, "strict", z.ZodTypeAny, {
|
|
10574
|
+
instructions: string;
|
|
10575
|
+
model: string;
|
|
10576
|
+
tools?: string[] | undefined;
|
|
10577
|
+
model_tiers?: {
|
|
10578
|
+
default: string;
|
|
10579
|
+
fast: string;
|
|
10580
|
+
routing?: {
|
|
10581
|
+
contextTokenThreshold?: number | undefined;
|
|
10582
|
+
toolsToDefault?: boolean | undefined;
|
|
10583
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10584
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10585
|
+
} | undefined;
|
|
10586
|
+
} | undefined;
|
|
10587
|
+
model_fallbacks?: string[] | undefined;
|
|
10588
|
+
circuit_breaker?: {
|
|
10589
|
+
failureThreshold?: number | undefined;
|
|
10590
|
+
windowMs?: number | undefined;
|
|
10591
|
+
cooldownMs?: number | undefined;
|
|
10592
|
+
} | undefined;
|
|
10593
|
+
model_pool?: {
|
|
10594
|
+
candidates: {
|
|
10595
|
+
model: string;
|
|
10596
|
+
tags: string[];
|
|
10597
|
+
}[];
|
|
10598
|
+
policy: "static" | "heuristic" | "learned";
|
|
10599
|
+
routing?: {
|
|
10600
|
+
contextTokenThreshold?: number | undefined;
|
|
10601
|
+
toolsToDefault?: boolean | undefined;
|
|
10602
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10603
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10604
|
+
strongTag?: string | undefined;
|
|
10605
|
+
cheapTag?: string | undefined;
|
|
10606
|
+
} | undefined;
|
|
10607
|
+
objective?: {
|
|
10608
|
+
quality?: number | undefined;
|
|
10609
|
+
cost?: number | undefined;
|
|
10610
|
+
latency?: number | undefined;
|
|
10611
|
+
} | undefined;
|
|
10612
|
+
learning?: {
|
|
10613
|
+
minSamplesPerArm?: number | undefined;
|
|
10614
|
+
costRefUsd?: number | undefined;
|
|
10615
|
+
latencyRefMs?: number | undefined;
|
|
10616
|
+
} | undefined;
|
|
10617
|
+
} | undefined;
|
|
10618
|
+
sub_agents?: Record<string, {
|
|
10619
|
+
description: string;
|
|
10620
|
+
instructions: string;
|
|
10621
|
+
tools?: string[] | undefined;
|
|
10622
|
+
model?: string | undefined;
|
|
10623
|
+
permissions?: "inherit" | "scoped" | {
|
|
10624
|
+
allow: string[];
|
|
10625
|
+
deny: string[];
|
|
10626
|
+
} | undefined;
|
|
10627
|
+
inherit_bypass?: boolean | undefined;
|
|
10628
|
+
}> | undefined;
|
|
10629
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
10630
|
+
}, {
|
|
10631
|
+
instructions: string;
|
|
10632
|
+
model: string;
|
|
10633
|
+
tools?: string[] | undefined;
|
|
10634
|
+
model_tiers?: {
|
|
10635
|
+
default: string;
|
|
10636
|
+
fast: string;
|
|
10637
|
+
routing?: {
|
|
10638
|
+
contextTokenThreshold?: number | undefined;
|
|
10639
|
+
toolsToDefault?: boolean | undefined;
|
|
10640
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10641
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10642
|
+
} | undefined;
|
|
10643
|
+
} | undefined;
|
|
10644
|
+
model_fallbacks?: string[] | undefined;
|
|
10645
|
+
circuit_breaker?: {
|
|
10646
|
+
failureThreshold?: number | undefined;
|
|
10647
|
+
windowMs?: number | undefined;
|
|
10648
|
+
cooldownMs?: number | undefined;
|
|
10649
|
+
} | undefined;
|
|
10650
|
+
model_pool?: {
|
|
10651
|
+
candidates: {
|
|
10652
|
+
model: string;
|
|
10653
|
+
tags?: string[] | undefined;
|
|
10654
|
+
}[];
|
|
10655
|
+
routing?: {
|
|
10656
|
+
contextTokenThreshold?: number | undefined;
|
|
10657
|
+
toolsToDefault?: boolean | undefined;
|
|
10658
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10659
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10660
|
+
strongTag?: string | undefined;
|
|
10661
|
+
cheapTag?: string | undefined;
|
|
10662
|
+
} | undefined;
|
|
10663
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
10664
|
+
objective?: {
|
|
10665
|
+
quality?: number | undefined;
|
|
10666
|
+
cost?: number | undefined;
|
|
10667
|
+
latency?: number | undefined;
|
|
10668
|
+
} | undefined;
|
|
10669
|
+
learning?: {
|
|
10670
|
+
minSamplesPerArm?: number | undefined;
|
|
10671
|
+
costRefUsd?: number | undefined;
|
|
10672
|
+
latencyRefMs?: number | undefined;
|
|
10673
|
+
} | undefined;
|
|
10674
|
+
} | undefined;
|
|
10675
|
+
sub_agents?: Record<string, {
|
|
8784
10676
|
description: string;
|
|
8785
10677
|
instructions: string;
|
|
8786
10678
|
tools?: string[] | undefined;
|
|
@@ -8790,25 +10682,51 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8790
10682
|
deny: string[];
|
|
8791
10683
|
} | undefined;
|
|
8792
10684
|
inherit_bypass?: boolean | undefined;
|
|
8793
|
-
}
|
|
8794
|
-
|
|
10685
|
+
}> | undefined;
|
|
10686
|
+
tool_config?: Record<string, unknown> | undefined;
|
|
10687
|
+
}>, {
|
|
8795
10688
|
instructions: string;
|
|
8796
10689
|
model: string;
|
|
8797
10690
|
tools?: string[] | undefined;
|
|
10691
|
+
model_tiers?: {
|
|
10692
|
+
default: string;
|
|
10693
|
+
fast: string;
|
|
10694
|
+
routing?: {
|
|
10695
|
+
contextTokenThreshold?: number | undefined;
|
|
10696
|
+
toolsToDefault?: boolean | undefined;
|
|
10697
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10698
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10699
|
+
} | undefined;
|
|
10700
|
+
} | undefined;
|
|
8798
10701
|
model_fallbacks?: string[] | undefined;
|
|
8799
10702
|
circuit_breaker?: {
|
|
8800
10703
|
failureThreshold?: number | undefined;
|
|
8801
10704
|
windowMs?: number | undefined;
|
|
8802
10705
|
cooldownMs?: number | undefined;
|
|
8803
10706
|
} | undefined;
|
|
8804
|
-
|
|
8805
|
-
|
|
8806
|
-
|
|
10707
|
+
model_pool?: {
|
|
10708
|
+
candidates: {
|
|
10709
|
+
model: string;
|
|
10710
|
+
tags: string[];
|
|
10711
|
+
}[];
|
|
10712
|
+
policy: "static" | "heuristic" | "learned";
|
|
8807
10713
|
routing?: {
|
|
8808
10714
|
contextTokenThreshold?: number | undefined;
|
|
8809
10715
|
toolsToDefault?: boolean | undefined;
|
|
8810
10716
|
firstTurnToDefault?: boolean | undefined;
|
|
8811
10717
|
priorToolDensityThreshold?: number | undefined;
|
|
10718
|
+
strongTag?: string | undefined;
|
|
10719
|
+
cheapTag?: string | undefined;
|
|
10720
|
+
} | undefined;
|
|
10721
|
+
objective?: {
|
|
10722
|
+
quality?: number | undefined;
|
|
10723
|
+
cost?: number | undefined;
|
|
10724
|
+
latency?: number | undefined;
|
|
10725
|
+
} | undefined;
|
|
10726
|
+
learning?: {
|
|
10727
|
+
minSamplesPerArm?: number | undefined;
|
|
10728
|
+
costRefUsd?: number | undefined;
|
|
10729
|
+
latencyRefMs?: number | undefined;
|
|
8812
10730
|
} | undefined;
|
|
8813
10731
|
} | undefined;
|
|
8814
10732
|
sub_agents?: Record<string, {
|
|
@@ -8827,20 +10745,45 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
8827
10745
|
instructions: string;
|
|
8828
10746
|
model: string;
|
|
8829
10747
|
tools?: string[] | undefined;
|
|
10748
|
+
model_tiers?: {
|
|
10749
|
+
default: string;
|
|
10750
|
+
fast: string;
|
|
10751
|
+
routing?: {
|
|
10752
|
+
contextTokenThreshold?: number | undefined;
|
|
10753
|
+
toolsToDefault?: boolean | undefined;
|
|
10754
|
+
firstTurnToDefault?: boolean | undefined;
|
|
10755
|
+
priorToolDensityThreshold?: number | undefined;
|
|
10756
|
+
} | undefined;
|
|
10757
|
+
} | undefined;
|
|
8830
10758
|
model_fallbacks?: string[] | undefined;
|
|
8831
10759
|
circuit_breaker?: {
|
|
8832
10760
|
failureThreshold?: number | undefined;
|
|
8833
10761
|
windowMs?: number | undefined;
|
|
8834
10762
|
cooldownMs?: number | undefined;
|
|
8835
10763
|
} | undefined;
|
|
8836
|
-
|
|
8837
|
-
|
|
8838
|
-
|
|
10764
|
+
model_pool?: {
|
|
10765
|
+
candidates: {
|
|
10766
|
+
model: string;
|
|
10767
|
+
tags?: string[] | undefined;
|
|
10768
|
+
}[];
|
|
8839
10769
|
routing?: {
|
|
8840
10770
|
contextTokenThreshold?: number | undefined;
|
|
8841
10771
|
toolsToDefault?: boolean | undefined;
|
|
8842
10772
|
firstTurnToDefault?: boolean | undefined;
|
|
8843
10773
|
priorToolDensityThreshold?: number | undefined;
|
|
10774
|
+
strongTag?: string | undefined;
|
|
10775
|
+
cheapTag?: string | undefined;
|
|
10776
|
+
} | undefined;
|
|
10777
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
10778
|
+
objective?: {
|
|
10779
|
+
quality?: number | undefined;
|
|
10780
|
+
cost?: number | undefined;
|
|
10781
|
+
latency?: number | undefined;
|
|
10782
|
+
} | undefined;
|
|
10783
|
+
learning?: {
|
|
10784
|
+
minSamplesPerArm?: number | undefined;
|
|
10785
|
+
costRefUsd?: number | undefined;
|
|
10786
|
+
latencyRefMs?: number | undefined;
|
|
8844
10787
|
} | undefined;
|
|
8845
10788
|
} | undefined;
|
|
8846
10789
|
sub_agents?: Record<string, {
|
|
@@ -9440,20 +11383,45 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
9440
11383
|
instructions: string;
|
|
9441
11384
|
model: string;
|
|
9442
11385
|
tools?: string[] | undefined;
|
|
11386
|
+
model_tiers?: {
|
|
11387
|
+
default: string;
|
|
11388
|
+
fast: string;
|
|
11389
|
+
routing?: {
|
|
11390
|
+
contextTokenThreshold?: number | undefined;
|
|
11391
|
+
toolsToDefault?: boolean | undefined;
|
|
11392
|
+
firstTurnToDefault?: boolean | undefined;
|
|
11393
|
+
priorToolDensityThreshold?: number | undefined;
|
|
11394
|
+
} | undefined;
|
|
11395
|
+
} | undefined;
|
|
9443
11396
|
model_fallbacks?: string[] | undefined;
|
|
9444
11397
|
circuit_breaker?: {
|
|
9445
11398
|
failureThreshold?: number | undefined;
|
|
9446
11399
|
windowMs?: number | undefined;
|
|
9447
11400
|
cooldownMs?: number | undefined;
|
|
9448
11401
|
} | undefined;
|
|
9449
|
-
|
|
9450
|
-
|
|
9451
|
-
|
|
11402
|
+
model_pool?: {
|
|
11403
|
+
candidates: {
|
|
11404
|
+
model: string;
|
|
11405
|
+
tags: string[];
|
|
11406
|
+
}[];
|
|
11407
|
+
policy: "static" | "heuristic" | "learned";
|
|
9452
11408
|
routing?: {
|
|
9453
11409
|
contextTokenThreshold?: number | undefined;
|
|
9454
11410
|
toolsToDefault?: boolean | undefined;
|
|
9455
11411
|
firstTurnToDefault?: boolean | undefined;
|
|
9456
11412
|
priorToolDensityThreshold?: number | undefined;
|
|
11413
|
+
strongTag?: string | undefined;
|
|
11414
|
+
cheapTag?: string | undefined;
|
|
11415
|
+
} | undefined;
|
|
11416
|
+
objective?: {
|
|
11417
|
+
quality?: number | undefined;
|
|
11418
|
+
cost?: number | undefined;
|
|
11419
|
+
latency?: number | undefined;
|
|
11420
|
+
} | undefined;
|
|
11421
|
+
learning?: {
|
|
11422
|
+
minSamplesPerArm?: number | undefined;
|
|
11423
|
+
costRefUsd?: number | undefined;
|
|
11424
|
+
latencyRefMs?: number | undefined;
|
|
9457
11425
|
} | undefined;
|
|
9458
11426
|
} | undefined;
|
|
9459
11427
|
sub_agents?: Record<string, {
|
|
@@ -9618,20 +11586,45 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
9618
11586
|
instructions: string;
|
|
9619
11587
|
model: string;
|
|
9620
11588
|
tools?: string[] | undefined;
|
|
11589
|
+
model_tiers?: {
|
|
11590
|
+
default: string;
|
|
11591
|
+
fast: string;
|
|
11592
|
+
routing?: {
|
|
11593
|
+
contextTokenThreshold?: number | undefined;
|
|
11594
|
+
toolsToDefault?: boolean | undefined;
|
|
11595
|
+
firstTurnToDefault?: boolean | undefined;
|
|
11596
|
+
priorToolDensityThreshold?: number | undefined;
|
|
11597
|
+
} | undefined;
|
|
11598
|
+
} | undefined;
|
|
9621
11599
|
model_fallbacks?: string[] | undefined;
|
|
9622
11600
|
circuit_breaker?: {
|
|
9623
11601
|
failureThreshold?: number | undefined;
|
|
9624
11602
|
windowMs?: number | undefined;
|
|
9625
11603
|
cooldownMs?: number | undefined;
|
|
9626
11604
|
} | undefined;
|
|
9627
|
-
|
|
9628
|
-
|
|
9629
|
-
|
|
11605
|
+
model_pool?: {
|
|
11606
|
+
candidates: {
|
|
11607
|
+
model: string;
|
|
11608
|
+
tags?: string[] | undefined;
|
|
11609
|
+
}[];
|
|
9630
11610
|
routing?: {
|
|
9631
11611
|
contextTokenThreshold?: number | undefined;
|
|
9632
11612
|
toolsToDefault?: boolean | undefined;
|
|
9633
11613
|
firstTurnToDefault?: boolean | undefined;
|
|
9634
11614
|
priorToolDensityThreshold?: number | undefined;
|
|
11615
|
+
strongTag?: string | undefined;
|
|
11616
|
+
cheapTag?: string | undefined;
|
|
11617
|
+
} | undefined;
|
|
11618
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
11619
|
+
objective?: {
|
|
11620
|
+
quality?: number | undefined;
|
|
11621
|
+
cost?: number | undefined;
|
|
11622
|
+
latency?: number | undefined;
|
|
11623
|
+
} | undefined;
|
|
11624
|
+
learning?: {
|
|
11625
|
+
minSamplesPerArm?: number | undefined;
|
|
11626
|
+
costRefUsd?: number | undefined;
|
|
11627
|
+
latencyRefMs?: number | undefined;
|
|
9635
11628
|
} | undefined;
|
|
9636
11629
|
} | undefined;
|
|
9637
11630
|
sub_agents?: Record<string, {
|
|
@@ -10166,7 +12159,7 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10166
12159
|
name: z.ZodString;
|
|
10167
12160
|
version: z.ZodOptional<z.ZodNumber>;
|
|
10168
12161
|
target: z.ZodLiteral<"managed">;
|
|
10169
|
-
agent: z.ZodObject<{
|
|
12162
|
+
agent: z.ZodEffects<z.ZodObject<{
|
|
10170
12163
|
model: z.ZodString;
|
|
10171
12164
|
instructions: z.ZodString;
|
|
10172
12165
|
model_fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -10224,15 +12217,162 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10224
12217
|
priorToolDensityThreshold?: number | undefined;
|
|
10225
12218
|
} | undefined;
|
|
10226
12219
|
}>>;
|
|
12220
|
+
model_pool: z.ZodOptional<z.ZodObject<{
|
|
12221
|
+
candidates: z.ZodArray<z.ZodObject<{
|
|
12222
|
+
model: z.ZodString;
|
|
12223
|
+
tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
|
|
12224
|
+
}, "strict", z.ZodTypeAny, {
|
|
12225
|
+
model: string;
|
|
12226
|
+
tags: string[];
|
|
12227
|
+
}, {
|
|
12228
|
+
model: string;
|
|
12229
|
+
tags?: string[] | undefined;
|
|
12230
|
+
}>, "many">;
|
|
12231
|
+
policy: z.ZodDefault<z.ZodEnum<["static", "heuristic", "learned"]>>;
|
|
12232
|
+
objective: z.ZodOptional<z.ZodObject<{
|
|
12233
|
+
quality: z.ZodOptional<z.ZodNumber>;
|
|
12234
|
+
cost: z.ZodOptional<z.ZodNumber>;
|
|
12235
|
+
latency: z.ZodOptional<z.ZodNumber>;
|
|
12236
|
+
}, "strict", z.ZodTypeAny, {
|
|
12237
|
+
quality?: number | undefined;
|
|
12238
|
+
cost?: number | undefined;
|
|
12239
|
+
latency?: number | undefined;
|
|
12240
|
+
}, {
|
|
12241
|
+
quality?: number | undefined;
|
|
12242
|
+
cost?: number | undefined;
|
|
12243
|
+
latency?: number | undefined;
|
|
12244
|
+
}>>;
|
|
12245
|
+
routing: z.ZodOptional<z.ZodObject<{
|
|
12246
|
+
contextTokenThreshold: z.ZodOptional<z.ZodNumber>;
|
|
12247
|
+
toolsToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
12248
|
+
firstTurnToDefault: z.ZodOptional<z.ZodBoolean>;
|
|
12249
|
+
priorToolDensityThreshold: z.ZodOptional<z.ZodNumber>;
|
|
12250
|
+
strongTag: z.ZodOptional<z.ZodString>;
|
|
12251
|
+
cheapTag: z.ZodOptional<z.ZodString>;
|
|
12252
|
+
}, "strict", z.ZodTypeAny, {
|
|
12253
|
+
contextTokenThreshold?: number | undefined;
|
|
12254
|
+
toolsToDefault?: boolean | undefined;
|
|
12255
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12256
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12257
|
+
strongTag?: string | undefined;
|
|
12258
|
+
cheapTag?: string | undefined;
|
|
12259
|
+
}, {
|
|
12260
|
+
contextTokenThreshold?: number | undefined;
|
|
12261
|
+
toolsToDefault?: boolean | undefined;
|
|
12262
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12263
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12264
|
+
strongTag?: string | undefined;
|
|
12265
|
+
cheapTag?: string | undefined;
|
|
12266
|
+
}>>;
|
|
12267
|
+
learning: z.ZodOptional<z.ZodObject<{
|
|
12268
|
+
minSamplesPerArm: z.ZodOptional<z.ZodNumber>;
|
|
12269
|
+
costRefUsd: z.ZodOptional<z.ZodNumber>;
|
|
12270
|
+
latencyRefMs: z.ZodOptional<z.ZodNumber>;
|
|
12271
|
+
}, "strict", z.ZodTypeAny, {
|
|
12272
|
+
minSamplesPerArm?: number | undefined;
|
|
12273
|
+
costRefUsd?: number | undefined;
|
|
12274
|
+
latencyRefMs?: number | undefined;
|
|
12275
|
+
}, {
|
|
12276
|
+
minSamplesPerArm?: number | undefined;
|
|
12277
|
+
costRefUsd?: number | undefined;
|
|
12278
|
+
latencyRefMs?: number | undefined;
|
|
12279
|
+
}>>;
|
|
12280
|
+
}, "strict", z.ZodTypeAny, {
|
|
12281
|
+
candidates: {
|
|
12282
|
+
model: string;
|
|
12283
|
+
tags: string[];
|
|
12284
|
+
}[];
|
|
12285
|
+
policy: "static" | "heuristic" | "learned";
|
|
12286
|
+
routing?: {
|
|
12287
|
+
contextTokenThreshold?: number | undefined;
|
|
12288
|
+
toolsToDefault?: boolean | undefined;
|
|
12289
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12290
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12291
|
+
strongTag?: string | undefined;
|
|
12292
|
+
cheapTag?: string | undefined;
|
|
12293
|
+
} | undefined;
|
|
12294
|
+
objective?: {
|
|
12295
|
+
quality?: number | undefined;
|
|
12296
|
+
cost?: number | undefined;
|
|
12297
|
+
latency?: number | undefined;
|
|
12298
|
+
} | undefined;
|
|
12299
|
+
learning?: {
|
|
12300
|
+
minSamplesPerArm?: number | undefined;
|
|
12301
|
+
costRefUsd?: number | undefined;
|
|
12302
|
+
latencyRefMs?: number | undefined;
|
|
12303
|
+
} | undefined;
|
|
12304
|
+
}, {
|
|
12305
|
+
candidates: {
|
|
12306
|
+
model: string;
|
|
12307
|
+
tags?: string[] | undefined;
|
|
12308
|
+
}[];
|
|
12309
|
+
routing?: {
|
|
12310
|
+
contextTokenThreshold?: number | undefined;
|
|
12311
|
+
toolsToDefault?: boolean | undefined;
|
|
12312
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12313
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12314
|
+
strongTag?: string | undefined;
|
|
12315
|
+
cheapTag?: string | undefined;
|
|
12316
|
+
} | undefined;
|
|
12317
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
12318
|
+
objective?: {
|
|
12319
|
+
quality?: number | undefined;
|
|
12320
|
+
cost?: number | undefined;
|
|
12321
|
+
latency?: number | undefined;
|
|
12322
|
+
} | undefined;
|
|
12323
|
+
learning?: {
|
|
12324
|
+
minSamplesPerArm?: number | undefined;
|
|
12325
|
+
costRefUsd?: number | undefined;
|
|
12326
|
+
latencyRefMs?: number | undefined;
|
|
12327
|
+
} | undefined;
|
|
12328
|
+
}>>;
|
|
10227
12329
|
}, "strict", z.ZodTypeAny, {
|
|
10228
12330
|
instructions: string;
|
|
10229
12331
|
model: string;
|
|
12332
|
+
model_tiers?: {
|
|
12333
|
+
default: string;
|
|
12334
|
+
fast: string;
|
|
12335
|
+
routing?: {
|
|
12336
|
+
contextTokenThreshold?: number | undefined;
|
|
12337
|
+
toolsToDefault?: boolean | undefined;
|
|
12338
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12339
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12340
|
+
} | undefined;
|
|
12341
|
+
} | undefined;
|
|
10230
12342
|
model_fallbacks?: string[] | undefined;
|
|
10231
12343
|
circuit_breaker?: {
|
|
10232
12344
|
failureThreshold?: number | undefined;
|
|
10233
12345
|
windowMs?: number | undefined;
|
|
10234
12346
|
cooldownMs?: number | undefined;
|
|
10235
12347
|
} | undefined;
|
|
12348
|
+
model_pool?: {
|
|
12349
|
+
candidates: {
|
|
12350
|
+
model: string;
|
|
12351
|
+
tags: string[];
|
|
12352
|
+
}[];
|
|
12353
|
+
policy: "static" | "heuristic" | "learned";
|
|
12354
|
+
routing?: {
|
|
12355
|
+
contextTokenThreshold?: number | undefined;
|
|
12356
|
+
toolsToDefault?: boolean | undefined;
|
|
12357
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12358
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12359
|
+
strongTag?: string | undefined;
|
|
12360
|
+
cheapTag?: string | undefined;
|
|
12361
|
+
} | undefined;
|
|
12362
|
+
objective?: {
|
|
12363
|
+
quality?: number | undefined;
|
|
12364
|
+
cost?: number | undefined;
|
|
12365
|
+
latency?: number | undefined;
|
|
12366
|
+
} | undefined;
|
|
12367
|
+
learning?: {
|
|
12368
|
+
minSamplesPerArm?: number | undefined;
|
|
12369
|
+
costRefUsd?: number | undefined;
|
|
12370
|
+
latencyRefMs?: number | undefined;
|
|
12371
|
+
} | undefined;
|
|
12372
|
+
} | undefined;
|
|
12373
|
+
}, {
|
|
12374
|
+
instructions: string;
|
|
12375
|
+
model: string;
|
|
10236
12376
|
model_tiers?: {
|
|
10237
12377
|
default: string;
|
|
10238
12378
|
fast: string;
|
|
@@ -10243,15 +12383,84 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10243
12383
|
priorToolDensityThreshold?: number | undefined;
|
|
10244
12384
|
} | undefined;
|
|
10245
12385
|
} | undefined;
|
|
10246
|
-
|
|
12386
|
+
model_fallbacks?: string[] | undefined;
|
|
12387
|
+
circuit_breaker?: {
|
|
12388
|
+
failureThreshold?: number | undefined;
|
|
12389
|
+
windowMs?: number | undefined;
|
|
12390
|
+
cooldownMs?: number | undefined;
|
|
12391
|
+
} | undefined;
|
|
12392
|
+
model_pool?: {
|
|
12393
|
+
candidates: {
|
|
12394
|
+
model: string;
|
|
12395
|
+
tags?: string[] | undefined;
|
|
12396
|
+
}[];
|
|
12397
|
+
routing?: {
|
|
12398
|
+
contextTokenThreshold?: number | undefined;
|
|
12399
|
+
toolsToDefault?: boolean | undefined;
|
|
12400
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12401
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12402
|
+
strongTag?: string | undefined;
|
|
12403
|
+
cheapTag?: string | undefined;
|
|
12404
|
+
} | undefined;
|
|
12405
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
12406
|
+
objective?: {
|
|
12407
|
+
quality?: number | undefined;
|
|
12408
|
+
cost?: number | undefined;
|
|
12409
|
+
latency?: number | undefined;
|
|
12410
|
+
} | undefined;
|
|
12411
|
+
learning?: {
|
|
12412
|
+
minSamplesPerArm?: number | undefined;
|
|
12413
|
+
costRefUsd?: number | undefined;
|
|
12414
|
+
latencyRefMs?: number | undefined;
|
|
12415
|
+
} | undefined;
|
|
12416
|
+
} | undefined;
|
|
12417
|
+
}>, {
|
|
10247
12418
|
instructions: string;
|
|
10248
12419
|
model: string;
|
|
12420
|
+
model_tiers?: {
|
|
12421
|
+
default: string;
|
|
12422
|
+
fast: string;
|
|
12423
|
+
routing?: {
|
|
12424
|
+
contextTokenThreshold?: number | undefined;
|
|
12425
|
+
toolsToDefault?: boolean | undefined;
|
|
12426
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12427
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12428
|
+
} | undefined;
|
|
12429
|
+
} | undefined;
|
|
10249
12430
|
model_fallbacks?: string[] | undefined;
|
|
10250
12431
|
circuit_breaker?: {
|
|
10251
12432
|
failureThreshold?: number | undefined;
|
|
10252
12433
|
windowMs?: number | undefined;
|
|
10253
12434
|
cooldownMs?: number | undefined;
|
|
10254
12435
|
} | undefined;
|
|
12436
|
+
model_pool?: {
|
|
12437
|
+
candidates: {
|
|
12438
|
+
model: string;
|
|
12439
|
+
tags: string[];
|
|
12440
|
+
}[];
|
|
12441
|
+
policy: "static" | "heuristic" | "learned";
|
|
12442
|
+
routing?: {
|
|
12443
|
+
contextTokenThreshold?: number | undefined;
|
|
12444
|
+
toolsToDefault?: boolean | undefined;
|
|
12445
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12446
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12447
|
+
strongTag?: string | undefined;
|
|
12448
|
+
cheapTag?: string | undefined;
|
|
12449
|
+
} | undefined;
|
|
12450
|
+
objective?: {
|
|
12451
|
+
quality?: number | undefined;
|
|
12452
|
+
cost?: number | undefined;
|
|
12453
|
+
latency?: number | undefined;
|
|
12454
|
+
} | undefined;
|
|
12455
|
+
learning?: {
|
|
12456
|
+
minSamplesPerArm?: number | undefined;
|
|
12457
|
+
costRefUsd?: number | undefined;
|
|
12458
|
+
latencyRefMs?: number | undefined;
|
|
12459
|
+
} | undefined;
|
|
12460
|
+
} | undefined;
|
|
12461
|
+
}, {
|
|
12462
|
+
instructions: string;
|
|
12463
|
+
model: string;
|
|
10255
12464
|
model_tiers?: {
|
|
10256
12465
|
default: string;
|
|
10257
12466
|
fast: string;
|
|
@@ -10262,6 +12471,37 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10262
12471
|
priorToolDensityThreshold?: number | undefined;
|
|
10263
12472
|
} | undefined;
|
|
10264
12473
|
} | undefined;
|
|
12474
|
+
model_fallbacks?: string[] | undefined;
|
|
12475
|
+
circuit_breaker?: {
|
|
12476
|
+
failureThreshold?: number | undefined;
|
|
12477
|
+
windowMs?: number | undefined;
|
|
12478
|
+
cooldownMs?: number | undefined;
|
|
12479
|
+
} | undefined;
|
|
12480
|
+
model_pool?: {
|
|
12481
|
+
candidates: {
|
|
12482
|
+
model: string;
|
|
12483
|
+
tags?: string[] | undefined;
|
|
12484
|
+
}[];
|
|
12485
|
+
routing?: {
|
|
12486
|
+
contextTokenThreshold?: number | undefined;
|
|
12487
|
+
toolsToDefault?: boolean | undefined;
|
|
12488
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12489
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12490
|
+
strongTag?: string | undefined;
|
|
12491
|
+
cheapTag?: string | undefined;
|
|
12492
|
+
} | undefined;
|
|
12493
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
12494
|
+
objective?: {
|
|
12495
|
+
quality?: number | undefined;
|
|
12496
|
+
cost?: number | undefined;
|
|
12497
|
+
latency?: number | undefined;
|
|
12498
|
+
} | undefined;
|
|
12499
|
+
learning?: {
|
|
12500
|
+
minSamplesPerArm?: number | undefined;
|
|
12501
|
+
costRefUsd?: number | undefined;
|
|
12502
|
+
latencyRefMs?: number | undefined;
|
|
12503
|
+
} | undefined;
|
|
12504
|
+
} | undefined;
|
|
10265
12505
|
}>;
|
|
10266
12506
|
tenants: z.ZodArray<z.ZodObject<{
|
|
10267
12507
|
id: z.ZodString;
|
|
@@ -10495,20 +12735,45 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10495
12735
|
agent: {
|
|
10496
12736
|
instructions: string;
|
|
10497
12737
|
model: string;
|
|
12738
|
+
model_tiers?: {
|
|
12739
|
+
default: string;
|
|
12740
|
+
fast: string;
|
|
12741
|
+
routing?: {
|
|
12742
|
+
contextTokenThreshold?: number | undefined;
|
|
12743
|
+
toolsToDefault?: boolean | undefined;
|
|
12744
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12745
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12746
|
+
} | undefined;
|
|
12747
|
+
} | undefined;
|
|
10498
12748
|
model_fallbacks?: string[] | undefined;
|
|
10499
12749
|
circuit_breaker?: {
|
|
10500
12750
|
failureThreshold?: number | undefined;
|
|
10501
12751
|
windowMs?: number | undefined;
|
|
10502
12752
|
cooldownMs?: number | undefined;
|
|
10503
12753
|
} | undefined;
|
|
10504
|
-
|
|
10505
|
-
|
|
10506
|
-
|
|
12754
|
+
model_pool?: {
|
|
12755
|
+
candidates: {
|
|
12756
|
+
model: string;
|
|
12757
|
+
tags: string[];
|
|
12758
|
+
}[];
|
|
12759
|
+
policy: "static" | "heuristic" | "learned";
|
|
10507
12760
|
routing?: {
|
|
10508
12761
|
contextTokenThreshold?: number | undefined;
|
|
10509
12762
|
toolsToDefault?: boolean | undefined;
|
|
10510
12763
|
firstTurnToDefault?: boolean | undefined;
|
|
10511
12764
|
priorToolDensityThreshold?: number | undefined;
|
|
12765
|
+
strongTag?: string | undefined;
|
|
12766
|
+
cheapTag?: string | undefined;
|
|
12767
|
+
} | undefined;
|
|
12768
|
+
objective?: {
|
|
12769
|
+
quality?: number | undefined;
|
|
12770
|
+
cost?: number | undefined;
|
|
12771
|
+
latency?: number | undefined;
|
|
12772
|
+
} | undefined;
|
|
12773
|
+
learning?: {
|
|
12774
|
+
minSamplesPerArm?: number | undefined;
|
|
12775
|
+
costRefUsd?: number | undefined;
|
|
12776
|
+
latencyRefMs?: number | undefined;
|
|
10512
12777
|
} | undefined;
|
|
10513
12778
|
} | undefined;
|
|
10514
12779
|
};
|
|
@@ -10572,20 +12837,45 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
10572
12837
|
agent: {
|
|
10573
12838
|
instructions: string;
|
|
10574
12839
|
model: string;
|
|
12840
|
+
model_tiers?: {
|
|
12841
|
+
default: string;
|
|
12842
|
+
fast: string;
|
|
12843
|
+
routing?: {
|
|
12844
|
+
contextTokenThreshold?: number | undefined;
|
|
12845
|
+
toolsToDefault?: boolean | undefined;
|
|
12846
|
+
firstTurnToDefault?: boolean | undefined;
|
|
12847
|
+
priorToolDensityThreshold?: number | undefined;
|
|
12848
|
+
} | undefined;
|
|
12849
|
+
} | undefined;
|
|
10575
12850
|
model_fallbacks?: string[] | undefined;
|
|
10576
12851
|
circuit_breaker?: {
|
|
10577
12852
|
failureThreshold?: number | undefined;
|
|
10578
12853
|
windowMs?: number | undefined;
|
|
10579
12854
|
cooldownMs?: number | undefined;
|
|
10580
12855
|
} | undefined;
|
|
10581
|
-
|
|
10582
|
-
|
|
10583
|
-
|
|
12856
|
+
model_pool?: {
|
|
12857
|
+
candidates: {
|
|
12858
|
+
model: string;
|
|
12859
|
+
tags?: string[] | undefined;
|
|
12860
|
+
}[];
|
|
10584
12861
|
routing?: {
|
|
10585
12862
|
contextTokenThreshold?: number | undefined;
|
|
10586
12863
|
toolsToDefault?: boolean | undefined;
|
|
10587
12864
|
firstTurnToDefault?: boolean | undefined;
|
|
10588
12865
|
priorToolDensityThreshold?: number | undefined;
|
|
12866
|
+
strongTag?: string | undefined;
|
|
12867
|
+
cheapTag?: string | undefined;
|
|
12868
|
+
} | undefined;
|
|
12869
|
+
policy?: "static" | "heuristic" | "learned" | undefined;
|
|
12870
|
+
objective?: {
|
|
12871
|
+
quality?: number | undefined;
|
|
12872
|
+
cost?: number | undefined;
|
|
12873
|
+
latency?: number | undefined;
|
|
12874
|
+
} | undefined;
|
|
12875
|
+
learning?: {
|
|
12876
|
+
minSamplesPerArm?: number | undefined;
|
|
12877
|
+
costRefUsd?: number | undefined;
|
|
12878
|
+
latencyRefMs?: number | undefined;
|
|
10589
12879
|
} | undefined;
|
|
10590
12880
|
} | undefined;
|
|
10591
12881
|
};
|
|
@@ -13385,9 +15675,9 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
13385
15675
|
};
|
|
13386
15676
|
stateReader: string;
|
|
13387
15677
|
turnSemantics: "turn-based" | "real-time" | "async";
|
|
15678
|
+
objective?: string | undefined;
|
|
13388
15679
|
actionsContract?: string | undefined;
|
|
13389
15680
|
moveTimeoutMs?: number | undefined;
|
|
13390
|
-
objective?: string | undefined;
|
|
13391
15681
|
}, {
|
|
13392
15682
|
contract: {
|
|
13393
15683
|
id: string;
|
|
@@ -13396,10 +15686,10 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
13396
15686
|
abiRef: string;
|
|
13397
15687
|
};
|
|
13398
15688
|
stateReader: string;
|
|
15689
|
+
objective?: string | undefined;
|
|
13399
15690
|
actionsContract?: string | undefined;
|
|
13400
15691
|
turnSemantics?: "turn-based" | "real-time" | "async" | undefined;
|
|
13401
15692
|
moveTimeoutMs?: number | undefined;
|
|
13402
|
-
objective?: string | undefined;
|
|
13403
15693
|
}>;
|
|
13404
15694
|
transaction_policy: z.ZodDefault<z.ZodObject<{
|
|
13405
15695
|
defaultWriteApproval: z.ZodDefault<z.ZodEnum<["required", "policy", "none"]>>;
|
|
@@ -13564,9 +15854,9 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
13564
15854
|
};
|
|
13565
15855
|
stateReader: string;
|
|
13566
15856
|
turnSemantics: "turn-based" | "real-time" | "async";
|
|
15857
|
+
objective?: string | undefined;
|
|
13567
15858
|
actionsContract?: string | undefined;
|
|
13568
15859
|
moveTimeoutMs?: number | undefined;
|
|
13569
|
-
objective?: string | undefined;
|
|
13570
15860
|
};
|
|
13571
15861
|
tools?: string[] | undefined;
|
|
13572
15862
|
permissions?: {
|
|
@@ -13637,10 +15927,10 @@ export declare const Spec: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
|
|
|
13637
15927
|
abiRef: string;
|
|
13638
15928
|
};
|
|
13639
15929
|
stateReader: string;
|
|
15930
|
+
objective?: string | undefined;
|
|
13640
15931
|
actionsContract?: string | undefined;
|
|
13641
15932
|
turnSemantics?: "turn-based" | "real-time" | "async" | undefined;
|
|
13642
15933
|
moveTimeoutMs?: number | undefined;
|
|
13643
|
-
objective?: string | undefined;
|
|
13644
15934
|
};
|
|
13645
15935
|
tools?: string[] | undefined;
|
|
13646
15936
|
permissions?: {
|
|
@@ -13722,6 +16012,7 @@ export type SpecCompactionBlock = z.infer<typeof compactionBlock>;
|
|
|
13722
16012
|
export type SpecModelFallbacks = z.infer<typeof modelFallbacksBlock>;
|
|
13723
16013
|
export type SpecCircuitBreakerBlock = z.infer<typeof circuitBreakerBlock>;
|
|
13724
16014
|
export type SpecModelTiersBlock = z.infer<typeof modelTiersBlock>;
|
|
16015
|
+
export type SpecModelPoolBlock = z.infer<typeof modelPoolBlock>;
|
|
13725
16016
|
export type SpecBudgetBlock = z.infer<typeof budgetBlock>;
|
|
13726
16017
|
export type SpecSecurityBlock = z.infer<typeof securityBlock>;
|
|
13727
16018
|
export type SpecFeedbackBlock = z.infer<typeof feedbackBlock>;
|