@miradorlabs/web-grpc 4.0.0 → 4.1.0
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.
|
@@ -3004,6 +3004,117 @@ export interface ModelActivityGroup {
|
|
|
3004
3004
|
modelNames: string[];
|
|
3005
3005
|
}
|
|
3006
3006
|
|
|
3007
|
+
export interface ListModelReasoningRequest {
|
|
3008
|
+
organizationId: string;
|
|
3009
|
+
projectId: string;
|
|
3010
|
+
/** Folds stored model names (recorded and served) into keys, as ModelActivityRequest.groups. */
|
|
3011
|
+
groups: ModelActivityGroup[];
|
|
3012
|
+
/**
|
|
3013
|
+
* Folds stored effort spellings into keys by the same rules, at most 64 groups of at most 64 spellings each; ''
|
|
3014
|
+
* cannot be listed and is always its own key.
|
|
3015
|
+
*/
|
|
3016
|
+
effortGroups: EffortGroup[];
|
|
3017
|
+
/**
|
|
3018
|
+
* The half-open range [start_time, end_time) of event time, at most 113 days: up to 17 ISO weeks, and a baseline
|
|
3019
|
+
* for every week shown needs the 4 weeks before them requested too.
|
|
3020
|
+
*/
|
|
3021
|
+
startTime: Date | undefined;
|
|
3022
|
+
endTime: Date | undefined;
|
|
3023
|
+
}
|
|
3024
|
+
|
|
3025
|
+
export interface EffortGroup {
|
|
3026
|
+
key: string;
|
|
3027
|
+
effortNames: string[];
|
|
3028
|
+
}
|
|
3029
|
+
|
|
3030
|
+
export interface ListModelReasoningResponse {
|
|
3031
|
+
status:
|
|
3032
|
+
| ResponseStatus
|
|
3033
|
+
| undefined;
|
|
3034
|
+
/** Calls descending, then model_key, then effort_key ascending. */
|
|
3035
|
+
models: ModelReasoning[];
|
|
3036
|
+
coverage: ReasoningCoverage | undefined;
|
|
3037
|
+
servedModels: ReasoningServedModels | undefined;
|
|
3038
|
+
windowStart: Date | undefined;
|
|
3039
|
+
windowEnd: Date | undefined;
|
|
3040
|
+
}
|
|
3041
|
+
|
|
3042
|
+
/**
|
|
3043
|
+
* One (model, effort) pair: counted calls report a thinking count (zero included); percentiles are exact, the
|
|
3044
|
+
* smallest value whose cumulative count reaches ceil(level × n) (the lower middle value for an even n); a
|
|
3045
|
+
* percentile is absent when its count is 0.
|
|
3046
|
+
*/
|
|
3047
|
+
export interface ModelReasoning {
|
|
3048
|
+
modelKey: string;
|
|
3049
|
+
/** '' when the calls reported no effort. */
|
|
3050
|
+
effortKey: string;
|
|
3051
|
+
calls: number;
|
|
3052
|
+
countedCalls: number;
|
|
3053
|
+
zeroThinkingCalls: number;
|
|
3054
|
+
medianPerCall?: number | undefined;
|
|
3055
|
+
p90PerCall?: number | undefined;
|
|
3056
|
+
countedTurns: number;
|
|
3057
|
+
medianPerTurn?:
|
|
3058
|
+
| number
|
|
3059
|
+
| undefined;
|
|
3060
|
+
/**
|
|
3061
|
+
* Every ISO week (Monday 00:00 UTC) the range overlaps, oldest first, empty weeks included; the first can be
|
|
3062
|
+
* partial when start_time is mid-week, and the latest when end_time is.
|
|
3063
|
+
*/
|
|
3064
|
+
weeks: ModelReasoningWeek[];
|
|
3065
|
+
}
|
|
3066
|
+
|
|
3067
|
+
/**
|
|
3068
|
+
* One ISO week of a pair. median_per_call is the value at 1-based rank ceil(n / 2) of its n counted calls (the
|
|
3069
|
+
* lower middle for an even n); median_ci_low and median_ci_high are the nominal ~84% distribution-free rank interval
|
|
3070
|
+
* of the median (z = 1.405), the values at ranks floor(n/2 − 1.405·√n/2) and ceil(n/2 + 1.405·√n/2) + 1 clamped to
|
|
3071
|
+
* [1, n]: sample values, never interpolated. Coverage is nominal, not exact for a finite sample; non-overlap is a
|
|
3072
|
+
* heuristic, not a fixed-level test. All three are absent when counted_calls is 0.
|
|
3073
|
+
*/
|
|
3074
|
+
export interface ModelReasoningWeek {
|
|
3075
|
+
weekStart: Date | undefined;
|
|
3076
|
+
countedCalls: number;
|
|
3077
|
+
medianPerCall?: number | undefined;
|
|
3078
|
+
medianCiLow?: number | undefined;
|
|
3079
|
+
medianCiHigh?:
|
|
3080
|
+
| number
|
|
3081
|
+
| undefined;
|
|
3082
|
+
/** The four prior ISO weeks' counted calls pooled into one sample; present only when all four lie inside the range. */
|
|
3083
|
+
baseline?: ModelReasoningBaseline | undefined;
|
|
3084
|
+
}
|
|
3085
|
+
|
|
3086
|
+
/**
|
|
3087
|
+
* The pooled sample of a week's four prior ISO weeks, by the same median and interval rules; a prior week with no
|
|
3088
|
+
* counted call adds nothing. The median and bounds are absent when counted_calls is 0.
|
|
3089
|
+
*/
|
|
3090
|
+
export interface ModelReasoningBaseline {
|
|
3091
|
+
countedCalls: number;
|
|
3092
|
+
median?: number | undefined;
|
|
3093
|
+
ciLow?: number | undefined;
|
|
3094
|
+
ciHigh?: number | undefined;
|
|
3095
|
+
}
|
|
3096
|
+
|
|
3097
|
+
export interface ReasoningCoverage {
|
|
3098
|
+
calls: number;
|
|
3099
|
+
countedCalls: number;
|
|
3100
|
+
/** Sources with a counted call, ascending. */
|
|
3101
|
+
sourceSystems: string[];
|
|
3102
|
+
}
|
|
3103
|
+
|
|
3104
|
+
export interface ReasoningServedModels {
|
|
3105
|
+
servedCalls: number;
|
|
3106
|
+
/** Recorded and served models folding to different keys: an observed mismatch, a lower bound on substitution. */
|
|
3107
|
+
modelMismatchCalls: number;
|
|
3108
|
+
/** Calls descending, then label ascending; '' is the calls that reported none. */
|
|
3109
|
+
serviceTiers: LabelCount[];
|
|
3110
|
+
inferenceGeos: LabelCount[];
|
|
3111
|
+
}
|
|
3112
|
+
|
|
3113
|
+
export interface LabelCount {
|
|
3114
|
+
label: string;
|
|
3115
|
+
calls: number;
|
|
3116
|
+
}
|
|
3117
|
+
|
|
3007
3118
|
export interface ModelActivityResponse {
|
|
3008
3119
|
status: ResponseStatus | undefined;
|
|
3009
3120
|
models: ModelActivity[];
|
|
@@ -18220,28 +18331,34 @@ export const ModelActivityGroup: MessageFns<ModelActivityGroup> = {
|
|
|
18220
18331
|
},
|
|
18221
18332
|
};
|
|
18222
18333
|
|
|
18223
|
-
function
|
|
18224
|
-
return {
|
|
18334
|
+
function createBaseListModelReasoningRequest(): ListModelReasoningRequest {
|
|
18335
|
+
return { organizationId: "", projectId: "", groups: [], effortGroups: [], startTime: undefined, endTime: undefined };
|
|
18225
18336
|
}
|
|
18226
18337
|
|
|
18227
|
-
export const
|
|
18228
|
-
encode(message:
|
|
18229
|
-
if (message.
|
|
18230
|
-
|
|
18338
|
+
export const ListModelReasoningRequest: MessageFns<ListModelReasoningRequest> = {
|
|
18339
|
+
encode(message: ListModelReasoningRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
18340
|
+
if (message.organizationId !== "") {
|
|
18341
|
+
writer.uint32(10).string(message.organizationId);
|
|
18231
18342
|
}
|
|
18232
|
-
|
|
18233
|
-
|
|
18343
|
+
if (message.projectId !== "") {
|
|
18344
|
+
writer.uint32(18).string(message.projectId);
|
|
18234
18345
|
}
|
|
18235
|
-
|
|
18236
|
-
|
|
18346
|
+
for (const v of message.groups) {
|
|
18347
|
+
ModelActivityGroup.encode(v!, writer.uint32(26).fork()).join();
|
|
18237
18348
|
}
|
|
18238
|
-
|
|
18239
|
-
|
|
18349
|
+
for (const v of message.effortGroups) {
|
|
18350
|
+
EffortGroup.encode(v!, writer.uint32(34).fork()).join();
|
|
18351
|
+
}
|
|
18352
|
+
if (message.startTime !== undefined) {
|
|
18353
|
+
Timestamp.encode(toTimestamp(message.startTime), writer.uint32(42).fork()).join();
|
|
18354
|
+
}
|
|
18355
|
+
if (message.endTime !== undefined) {
|
|
18356
|
+
Timestamp.encode(toTimestamp(message.endTime), writer.uint32(50).fork()).join();
|
|
18240
18357
|
}
|
|
18241
18358
|
return writer;
|
|
18242
18359
|
},
|
|
18243
18360
|
|
|
18244
|
-
decode(input: BinaryReader | Uint8Array, length?: number):
|
|
18361
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ListModelReasoningRequest {
|
|
18245
18362
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
18246
18363
|
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
18247
18364
|
if (previousRecursionDepth >= 100) {
|
|
@@ -18250,7 +18367,7 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18250
18367
|
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
18251
18368
|
try {
|
|
18252
18369
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
18253
|
-
const message =
|
|
18370
|
+
const message = createBaseListModelReasoningRequest();
|
|
18254
18371
|
while (reader.pos < end) {
|
|
18255
18372
|
const tag = reader.uint32();
|
|
18256
18373
|
switch (tag >>> 3) {
|
|
@@ -18259,7 +18376,7 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18259
18376
|
break;
|
|
18260
18377
|
}
|
|
18261
18378
|
|
|
18262
|
-
message.
|
|
18379
|
+
message.organizationId = reader.string();
|
|
18263
18380
|
continue;
|
|
18264
18381
|
}
|
|
18265
18382
|
case 2: {
|
|
@@ -18267,7 +18384,7 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18267
18384
|
break;
|
|
18268
18385
|
}
|
|
18269
18386
|
|
|
18270
|
-
message.
|
|
18387
|
+
message.projectId = reader.string();
|
|
18271
18388
|
continue;
|
|
18272
18389
|
}
|
|
18273
18390
|
case 3: {
|
|
@@ -18275,7 +18392,7 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18275
18392
|
break;
|
|
18276
18393
|
}
|
|
18277
18394
|
|
|
18278
|
-
message.
|
|
18395
|
+
message.groups.push(ModelActivityGroup.decode(reader, reader.uint32()));
|
|
18279
18396
|
continue;
|
|
18280
18397
|
}
|
|
18281
18398
|
case 4: {
|
|
@@ -18283,7 +18400,23 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18283
18400
|
break;
|
|
18284
18401
|
}
|
|
18285
18402
|
|
|
18286
|
-
message.
|
|
18403
|
+
message.effortGroups.push(EffortGroup.decode(reader, reader.uint32()));
|
|
18404
|
+
continue;
|
|
18405
|
+
}
|
|
18406
|
+
case 5: {
|
|
18407
|
+
if (tag !== 42) {
|
|
18408
|
+
break;
|
|
18409
|
+
}
|
|
18410
|
+
|
|
18411
|
+
message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
18412
|
+
continue;
|
|
18413
|
+
}
|
|
18414
|
+
case 6: {
|
|
18415
|
+
if (tag !== 50) {
|
|
18416
|
+
break;
|
|
18417
|
+
}
|
|
18418
|
+
|
|
18419
|
+
message.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
18287
18420
|
continue;
|
|
18288
18421
|
}
|
|
18289
18422
|
}
|
|
@@ -18298,138 +18431,93 @@ export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
|
18298
18431
|
}
|
|
18299
18432
|
},
|
|
18300
18433
|
|
|
18301
|
-
fromJSON(object: any):
|
|
18434
|
+
fromJSON(object: any): ListModelReasoningRequest {
|
|
18302
18435
|
return {
|
|
18303
|
-
|
|
18304
|
-
|
|
18305
|
-
|
|
18306
|
-
?
|
|
18307
|
-
:
|
|
18308
|
-
|
|
18436
|
+
organizationId: isSet(object.organizationId)
|
|
18437
|
+
? globalThis.String(object.organizationId)
|
|
18438
|
+
: isSet(object.organization_id)
|
|
18439
|
+
? globalThis.String(object.organization_id)
|
|
18440
|
+
: "",
|
|
18441
|
+
projectId: isSet(object.projectId)
|
|
18442
|
+
? globalThis.String(object.projectId)
|
|
18443
|
+
: isSet(object.project_id)
|
|
18444
|
+
? globalThis.String(object.project_id)
|
|
18445
|
+
: "",
|
|
18446
|
+
groups: globalThis.Array.isArray(object?.groups)
|
|
18447
|
+
? object.groups.map((e: any) => ModelActivityGroup.fromJSON(e))
|
|
18448
|
+
: [],
|
|
18449
|
+
effortGroups: globalThis.Array.isArray(object?.effortGroups)
|
|
18450
|
+
? object.effortGroups.map((e: any) => EffortGroup.fromJSON(e))
|
|
18451
|
+
: globalThis.Array.isArray(object?.effort_groups)
|
|
18452
|
+
? object.effort_groups.map((e: any) => EffortGroup.fromJSON(e))
|
|
18453
|
+
: [],
|
|
18454
|
+
startTime: isSet(object.startTime)
|
|
18455
|
+
? fromJsonTimestamp(object.startTime)
|
|
18456
|
+
: isSet(object.start_time)
|
|
18457
|
+
? fromJsonTimestamp(object.start_time)
|
|
18309
18458
|
: undefined,
|
|
18310
|
-
|
|
18311
|
-
? fromJsonTimestamp(object.
|
|
18312
|
-
: isSet(object.
|
|
18313
|
-
? fromJsonTimestamp(object.
|
|
18459
|
+
endTime: isSet(object.endTime)
|
|
18460
|
+
? fromJsonTimestamp(object.endTime)
|
|
18461
|
+
: isSet(object.end_time)
|
|
18462
|
+
? fromJsonTimestamp(object.end_time)
|
|
18314
18463
|
: undefined,
|
|
18315
18464
|
};
|
|
18316
18465
|
},
|
|
18317
18466
|
|
|
18318
|
-
toJSON(message:
|
|
18467
|
+
toJSON(message: ListModelReasoningRequest): unknown {
|
|
18319
18468
|
const obj: any = {};
|
|
18320
|
-
if (message.
|
|
18321
|
-
obj.
|
|
18469
|
+
if (message.organizationId !== "") {
|
|
18470
|
+
obj.organizationId = message.organizationId;
|
|
18322
18471
|
}
|
|
18323
|
-
if (message.
|
|
18324
|
-
obj.
|
|
18472
|
+
if (message.projectId !== "") {
|
|
18473
|
+
obj.projectId = message.projectId;
|
|
18325
18474
|
}
|
|
18326
|
-
if (message.
|
|
18327
|
-
obj.
|
|
18475
|
+
if (message.groups?.length) {
|
|
18476
|
+
obj.groups = message.groups.map((e) => ModelActivityGroup.toJSON(e));
|
|
18328
18477
|
}
|
|
18329
|
-
if (message.
|
|
18330
|
-
obj.
|
|
18478
|
+
if (message.effortGroups?.length) {
|
|
18479
|
+
obj.effortGroups = message.effortGroups.map((e) => EffortGroup.toJSON(e));
|
|
18480
|
+
}
|
|
18481
|
+
if (message.startTime !== undefined) {
|
|
18482
|
+
obj.startTime = message.startTime.toISOString();
|
|
18483
|
+
}
|
|
18484
|
+
if (message.endTime !== undefined) {
|
|
18485
|
+
obj.endTime = message.endTime.toISOString();
|
|
18331
18486
|
}
|
|
18332
18487
|
return obj;
|
|
18333
18488
|
},
|
|
18334
18489
|
|
|
18335
|
-
create<I extends Exact<DeepPartial<
|
|
18336
|
-
return
|
|
18490
|
+
create<I extends Exact<DeepPartial<ListModelReasoningRequest>, I>>(base?: I): ListModelReasoningRequest {
|
|
18491
|
+
return ListModelReasoningRequest.fromPartial(base ?? ({} as any));
|
|
18337
18492
|
},
|
|
18338
|
-
fromPartial<I extends Exact<DeepPartial<
|
|
18339
|
-
const message =
|
|
18340
|
-
message.
|
|
18341
|
-
|
|
18342
|
-
|
|
18343
|
-
message.
|
|
18344
|
-
message.
|
|
18345
|
-
message.
|
|
18493
|
+
fromPartial<I extends Exact<DeepPartial<ListModelReasoningRequest>, I>>(object: I): ListModelReasoningRequest {
|
|
18494
|
+
const message = createBaseListModelReasoningRequest();
|
|
18495
|
+
message.organizationId = object.organizationId ?? "";
|
|
18496
|
+
message.projectId = object.projectId ?? "";
|
|
18497
|
+
message.groups = object.groups?.map((e) => ModelActivityGroup.fromPartial(e)) || [];
|
|
18498
|
+
message.effortGroups = object.effortGroups?.map((e) => EffortGroup.fromPartial(e)) || [];
|
|
18499
|
+
message.startTime = object.startTime ?? undefined;
|
|
18500
|
+
message.endTime = object.endTime ?? undefined;
|
|
18346
18501
|
return message;
|
|
18347
18502
|
},
|
|
18348
18503
|
};
|
|
18349
18504
|
|
|
18350
|
-
function
|
|
18351
|
-
return {
|
|
18352
|
-
key: "",
|
|
18353
|
-
modelCalls: 0,
|
|
18354
|
-
failedCalls: 0,
|
|
18355
|
-
inputTokens: 0,
|
|
18356
|
-
outputTokens: 0,
|
|
18357
|
-
cacheReadTokens: 0,
|
|
18358
|
-
cacheWriteTokens: 0,
|
|
18359
|
-
costUsd: 0,
|
|
18360
|
-
subscriptionCostUsd: 0,
|
|
18361
|
-
sessions: 0,
|
|
18362
|
-
toolCalls: 0,
|
|
18363
|
-
compactions: 0,
|
|
18364
|
-
subagentRuns: 0,
|
|
18365
|
-
ttftMsSum: 0,
|
|
18366
|
-
ttftCalls: 0,
|
|
18367
|
-
providers: [],
|
|
18368
|
-
principals: [],
|
|
18369
|
-
settledCalls: undefined,
|
|
18370
|
-
};
|
|
18505
|
+
function createBaseEffortGroup(): EffortGroup {
|
|
18506
|
+
return { key: "", effortNames: [] };
|
|
18371
18507
|
}
|
|
18372
18508
|
|
|
18373
|
-
export const
|
|
18374
|
-
encode(message:
|
|
18509
|
+
export const EffortGroup: MessageFns<EffortGroup> = {
|
|
18510
|
+
encode(message: EffortGroup, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
18375
18511
|
if (message.key !== "") {
|
|
18376
18512
|
writer.uint32(10).string(message.key);
|
|
18377
18513
|
}
|
|
18378
|
-
|
|
18379
|
-
writer.uint32(
|
|
18380
|
-
}
|
|
18381
|
-
if (message.failedCalls !== 0) {
|
|
18382
|
-
writer.uint32(24).uint64(message.failedCalls);
|
|
18383
|
-
}
|
|
18384
|
-
if (message.inputTokens !== 0) {
|
|
18385
|
-
writer.uint32(32).uint64(message.inputTokens);
|
|
18386
|
-
}
|
|
18387
|
-
if (message.outputTokens !== 0) {
|
|
18388
|
-
writer.uint32(40).uint64(message.outputTokens);
|
|
18389
|
-
}
|
|
18390
|
-
if (message.cacheReadTokens !== 0) {
|
|
18391
|
-
writer.uint32(48).uint64(message.cacheReadTokens);
|
|
18392
|
-
}
|
|
18393
|
-
if (message.cacheWriteTokens !== 0) {
|
|
18394
|
-
writer.uint32(56).uint64(message.cacheWriteTokens);
|
|
18395
|
-
}
|
|
18396
|
-
if (message.costUsd !== 0) {
|
|
18397
|
-
writer.uint32(65).double(message.costUsd);
|
|
18398
|
-
}
|
|
18399
|
-
if (message.subscriptionCostUsd !== 0) {
|
|
18400
|
-
writer.uint32(73).double(message.subscriptionCostUsd);
|
|
18401
|
-
}
|
|
18402
|
-
if (message.sessions !== 0) {
|
|
18403
|
-
writer.uint32(80).uint64(message.sessions);
|
|
18404
|
-
}
|
|
18405
|
-
if (message.toolCalls !== 0) {
|
|
18406
|
-
writer.uint32(88).uint64(message.toolCalls);
|
|
18407
|
-
}
|
|
18408
|
-
if (message.compactions !== 0) {
|
|
18409
|
-
writer.uint32(96).uint64(message.compactions);
|
|
18410
|
-
}
|
|
18411
|
-
if (message.subagentRuns !== 0) {
|
|
18412
|
-
writer.uint32(104).uint64(message.subagentRuns);
|
|
18413
|
-
}
|
|
18414
|
-
if (message.ttftMsSum !== 0) {
|
|
18415
|
-
writer.uint32(112).uint64(message.ttftMsSum);
|
|
18416
|
-
}
|
|
18417
|
-
if (message.ttftCalls !== 0) {
|
|
18418
|
-
writer.uint32(120).uint64(message.ttftCalls);
|
|
18419
|
-
}
|
|
18420
|
-
for (const v of message.providers) {
|
|
18421
|
-
writer.uint32(130).string(v!);
|
|
18422
|
-
}
|
|
18423
|
-
for (const v of message.principals) {
|
|
18424
|
-
ModelActivityPrincipal.encode(v!, writer.uint32(138).fork()).join();
|
|
18425
|
-
}
|
|
18426
|
-
if (message.settledCalls !== undefined) {
|
|
18427
|
-
writer.uint32(144).uint64(message.settledCalls);
|
|
18514
|
+
for (const v of message.effortNames) {
|
|
18515
|
+
writer.uint32(18).string(v!);
|
|
18428
18516
|
}
|
|
18429
18517
|
return writer;
|
|
18430
18518
|
},
|
|
18431
18519
|
|
|
18432
|
-
decode(input: BinaryReader | Uint8Array, length?: number):
|
|
18520
|
+
decode(input: BinaryReader | Uint8Array, length?: number): EffortGroup {
|
|
18433
18521
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
18434
18522
|
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
18435
18523
|
if (previousRecursionDepth >= 100) {
|
|
@@ -18438,7 +18526,7 @@ export const ModelActivity: MessageFns<ModelActivity> = {
|
|
|
18438
18526
|
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
18439
18527
|
try {
|
|
18440
18528
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
18441
|
-
const message =
|
|
18529
|
+
const message = createBaseEffortGroup();
|
|
18442
18530
|
while (reader.pos < end) {
|
|
18443
18531
|
const tag = reader.uint32();
|
|
18444
18532
|
switch (tag >>> 3) {
|
|
@@ -18451,17 +18539,1366 @@ export const ModelActivity: MessageFns<ModelActivity> = {
|
|
|
18451
18539
|
continue;
|
|
18452
18540
|
}
|
|
18453
18541
|
case 2: {
|
|
18454
|
-
if (tag !==
|
|
18542
|
+
if (tag !== 18) {
|
|
18455
18543
|
break;
|
|
18456
18544
|
}
|
|
18457
18545
|
|
|
18458
|
-
message.
|
|
18546
|
+
message.effortNames.push(reader.string());
|
|
18459
18547
|
continue;
|
|
18460
18548
|
}
|
|
18461
|
-
|
|
18462
|
-
|
|
18463
|
-
|
|
18464
|
-
|
|
18549
|
+
}
|
|
18550
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
18551
|
+
break;
|
|
18552
|
+
}
|
|
18553
|
+
reader.skip(tag & 7);
|
|
18554
|
+
}
|
|
18555
|
+
return message;
|
|
18556
|
+
} finally {
|
|
18557
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
18558
|
+
}
|
|
18559
|
+
},
|
|
18560
|
+
|
|
18561
|
+
fromJSON(object: any): EffortGroup {
|
|
18562
|
+
return {
|
|
18563
|
+
key: isSet(object.key) ? globalThis.String(object.key) : "",
|
|
18564
|
+
effortNames: globalThis.Array.isArray(object?.effortNames)
|
|
18565
|
+
? object.effortNames.map((e: any) => globalThis.String(e))
|
|
18566
|
+
: globalThis.Array.isArray(object?.effort_names)
|
|
18567
|
+
? object.effort_names.map((e: any) => globalThis.String(e))
|
|
18568
|
+
: [],
|
|
18569
|
+
};
|
|
18570
|
+
},
|
|
18571
|
+
|
|
18572
|
+
toJSON(message: EffortGroup): unknown {
|
|
18573
|
+
const obj: any = {};
|
|
18574
|
+
if (message.key !== "") {
|
|
18575
|
+
obj.key = message.key;
|
|
18576
|
+
}
|
|
18577
|
+
if (message.effortNames?.length) {
|
|
18578
|
+
obj.effortNames = message.effortNames;
|
|
18579
|
+
}
|
|
18580
|
+
return obj;
|
|
18581
|
+
},
|
|
18582
|
+
|
|
18583
|
+
create<I extends Exact<DeepPartial<EffortGroup>, I>>(base?: I): EffortGroup {
|
|
18584
|
+
return EffortGroup.fromPartial(base ?? ({} as any));
|
|
18585
|
+
},
|
|
18586
|
+
fromPartial<I extends Exact<DeepPartial<EffortGroup>, I>>(object: I): EffortGroup {
|
|
18587
|
+
const message = createBaseEffortGroup();
|
|
18588
|
+
message.key = object.key ?? "";
|
|
18589
|
+
message.effortNames = object.effortNames?.map((e) => e) || [];
|
|
18590
|
+
return message;
|
|
18591
|
+
},
|
|
18592
|
+
};
|
|
18593
|
+
|
|
18594
|
+
function createBaseListModelReasoningResponse(): ListModelReasoningResponse {
|
|
18595
|
+
return {
|
|
18596
|
+
status: undefined,
|
|
18597
|
+
models: [],
|
|
18598
|
+
coverage: undefined,
|
|
18599
|
+
servedModels: undefined,
|
|
18600
|
+
windowStart: undefined,
|
|
18601
|
+
windowEnd: undefined,
|
|
18602
|
+
};
|
|
18603
|
+
}
|
|
18604
|
+
|
|
18605
|
+
export const ListModelReasoningResponse: MessageFns<ListModelReasoningResponse> = {
|
|
18606
|
+
encode(message: ListModelReasoningResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
18607
|
+
if (message.status !== undefined) {
|
|
18608
|
+
ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
|
|
18609
|
+
}
|
|
18610
|
+
for (const v of message.models) {
|
|
18611
|
+
ModelReasoning.encode(v!, writer.uint32(18).fork()).join();
|
|
18612
|
+
}
|
|
18613
|
+
if (message.coverage !== undefined) {
|
|
18614
|
+
ReasoningCoverage.encode(message.coverage, writer.uint32(26).fork()).join();
|
|
18615
|
+
}
|
|
18616
|
+
if (message.servedModels !== undefined) {
|
|
18617
|
+
ReasoningServedModels.encode(message.servedModels, writer.uint32(34).fork()).join();
|
|
18618
|
+
}
|
|
18619
|
+
if (message.windowStart !== undefined) {
|
|
18620
|
+
Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(42).fork()).join();
|
|
18621
|
+
}
|
|
18622
|
+
if (message.windowEnd !== undefined) {
|
|
18623
|
+
Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(50).fork()).join();
|
|
18624
|
+
}
|
|
18625
|
+
return writer;
|
|
18626
|
+
},
|
|
18627
|
+
|
|
18628
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ListModelReasoningResponse {
|
|
18629
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
18630
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
18631
|
+
if (previousRecursionDepth >= 100) {
|
|
18632
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
18633
|
+
}
|
|
18634
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
18635
|
+
try {
|
|
18636
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
18637
|
+
const message = createBaseListModelReasoningResponse();
|
|
18638
|
+
while (reader.pos < end) {
|
|
18639
|
+
const tag = reader.uint32();
|
|
18640
|
+
switch (tag >>> 3) {
|
|
18641
|
+
case 1: {
|
|
18642
|
+
if (tag !== 10) {
|
|
18643
|
+
break;
|
|
18644
|
+
}
|
|
18645
|
+
|
|
18646
|
+
message.status = ResponseStatus.decode(reader, reader.uint32());
|
|
18647
|
+
continue;
|
|
18648
|
+
}
|
|
18649
|
+
case 2: {
|
|
18650
|
+
if (tag !== 18) {
|
|
18651
|
+
break;
|
|
18652
|
+
}
|
|
18653
|
+
|
|
18654
|
+
message.models.push(ModelReasoning.decode(reader, reader.uint32()));
|
|
18655
|
+
continue;
|
|
18656
|
+
}
|
|
18657
|
+
case 3: {
|
|
18658
|
+
if (tag !== 26) {
|
|
18659
|
+
break;
|
|
18660
|
+
}
|
|
18661
|
+
|
|
18662
|
+
message.coverage = ReasoningCoverage.decode(reader, reader.uint32());
|
|
18663
|
+
continue;
|
|
18664
|
+
}
|
|
18665
|
+
case 4: {
|
|
18666
|
+
if (tag !== 34) {
|
|
18667
|
+
break;
|
|
18668
|
+
}
|
|
18669
|
+
|
|
18670
|
+
message.servedModels = ReasoningServedModels.decode(reader, reader.uint32());
|
|
18671
|
+
continue;
|
|
18672
|
+
}
|
|
18673
|
+
case 5: {
|
|
18674
|
+
if (tag !== 42) {
|
|
18675
|
+
break;
|
|
18676
|
+
}
|
|
18677
|
+
|
|
18678
|
+
message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
18679
|
+
continue;
|
|
18680
|
+
}
|
|
18681
|
+
case 6: {
|
|
18682
|
+
if (tag !== 50) {
|
|
18683
|
+
break;
|
|
18684
|
+
}
|
|
18685
|
+
|
|
18686
|
+
message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
18687
|
+
continue;
|
|
18688
|
+
}
|
|
18689
|
+
}
|
|
18690
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
18691
|
+
break;
|
|
18692
|
+
}
|
|
18693
|
+
reader.skip(tag & 7);
|
|
18694
|
+
}
|
|
18695
|
+
return message;
|
|
18696
|
+
} finally {
|
|
18697
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
18698
|
+
}
|
|
18699
|
+
},
|
|
18700
|
+
|
|
18701
|
+
fromJSON(object: any): ListModelReasoningResponse {
|
|
18702
|
+
return {
|
|
18703
|
+
status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
|
|
18704
|
+
models: globalThis.Array.isArray(object?.models) ? object.models.map((e: any) => ModelReasoning.fromJSON(e)) : [],
|
|
18705
|
+
coverage: isSet(object.coverage) ? ReasoningCoverage.fromJSON(object.coverage) : undefined,
|
|
18706
|
+
servedModels: isSet(object.servedModels)
|
|
18707
|
+
? ReasoningServedModels.fromJSON(object.servedModels)
|
|
18708
|
+
: isSet(object.served_models)
|
|
18709
|
+
? ReasoningServedModels.fromJSON(object.served_models)
|
|
18710
|
+
: undefined,
|
|
18711
|
+
windowStart: isSet(object.windowStart)
|
|
18712
|
+
? fromJsonTimestamp(object.windowStart)
|
|
18713
|
+
: isSet(object.window_start)
|
|
18714
|
+
? fromJsonTimestamp(object.window_start)
|
|
18715
|
+
: undefined,
|
|
18716
|
+
windowEnd: isSet(object.windowEnd)
|
|
18717
|
+
? fromJsonTimestamp(object.windowEnd)
|
|
18718
|
+
: isSet(object.window_end)
|
|
18719
|
+
? fromJsonTimestamp(object.window_end)
|
|
18720
|
+
: undefined,
|
|
18721
|
+
};
|
|
18722
|
+
},
|
|
18723
|
+
|
|
18724
|
+
toJSON(message: ListModelReasoningResponse): unknown {
|
|
18725
|
+
const obj: any = {};
|
|
18726
|
+
if (message.status !== undefined) {
|
|
18727
|
+
obj.status = ResponseStatus.toJSON(message.status);
|
|
18728
|
+
}
|
|
18729
|
+
if (message.models?.length) {
|
|
18730
|
+
obj.models = message.models.map((e) => ModelReasoning.toJSON(e));
|
|
18731
|
+
}
|
|
18732
|
+
if (message.coverage !== undefined) {
|
|
18733
|
+
obj.coverage = ReasoningCoverage.toJSON(message.coverage);
|
|
18734
|
+
}
|
|
18735
|
+
if (message.servedModels !== undefined) {
|
|
18736
|
+
obj.servedModels = ReasoningServedModels.toJSON(message.servedModels);
|
|
18737
|
+
}
|
|
18738
|
+
if (message.windowStart !== undefined) {
|
|
18739
|
+
obj.windowStart = message.windowStart.toISOString();
|
|
18740
|
+
}
|
|
18741
|
+
if (message.windowEnd !== undefined) {
|
|
18742
|
+
obj.windowEnd = message.windowEnd.toISOString();
|
|
18743
|
+
}
|
|
18744
|
+
return obj;
|
|
18745
|
+
},
|
|
18746
|
+
|
|
18747
|
+
create<I extends Exact<DeepPartial<ListModelReasoningResponse>, I>>(base?: I): ListModelReasoningResponse {
|
|
18748
|
+
return ListModelReasoningResponse.fromPartial(base ?? ({} as any));
|
|
18749
|
+
},
|
|
18750
|
+
fromPartial<I extends Exact<DeepPartial<ListModelReasoningResponse>, I>>(object: I): ListModelReasoningResponse {
|
|
18751
|
+
const message = createBaseListModelReasoningResponse();
|
|
18752
|
+
message.status = (object.status !== undefined && object.status !== null)
|
|
18753
|
+
? ResponseStatus.fromPartial(object.status)
|
|
18754
|
+
: undefined;
|
|
18755
|
+
message.models = object.models?.map((e) => ModelReasoning.fromPartial(e)) || [];
|
|
18756
|
+
message.coverage = (object.coverage !== undefined && object.coverage !== null)
|
|
18757
|
+
? ReasoningCoverage.fromPartial(object.coverage)
|
|
18758
|
+
: undefined;
|
|
18759
|
+
message.servedModels = (object.servedModels !== undefined && object.servedModels !== null)
|
|
18760
|
+
? ReasoningServedModels.fromPartial(object.servedModels)
|
|
18761
|
+
: undefined;
|
|
18762
|
+
message.windowStart = object.windowStart ?? undefined;
|
|
18763
|
+
message.windowEnd = object.windowEnd ?? undefined;
|
|
18764
|
+
return message;
|
|
18765
|
+
},
|
|
18766
|
+
};
|
|
18767
|
+
|
|
18768
|
+
function createBaseModelReasoning(): ModelReasoning {
|
|
18769
|
+
return {
|
|
18770
|
+
modelKey: "",
|
|
18771
|
+
effortKey: "",
|
|
18772
|
+
calls: 0,
|
|
18773
|
+
countedCalls: 0,
|
|
18774
|
+
zeroThinkingCalls: 0,
|
|
18775
|
+
medianPerCall: undefined,
|
|
18776
|
+
p90PerCall: undefined,
|
|
18777
|
+
countedTurns: 0,
|
|
18778
|
+
medianPerTurn: undefined,
|
|
18779
|
+
weeks: [],
|
|
18780
|
+
};
|
|
18781
|
+
}
|
|
18782
|
+
|
|
18783
|
+
export const ModelReasoning: MessageFns<ModelReasoning> = {
|
|
18784
|
+
encode(message: ModelReasoning, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
18785
|
+
if (message.modelKey !== "") {
|
|
18786
|
+
writer.uint32(10).string(message.modelKey);
|
|
18787
|
+
}
|
|
18788
|
+
if (message.effortKey !== "") {
|
|
18789
|
+
writer.uint32(18).string(message.effortKey);
|
|
18790
|
+
}
|
|
18791
|
+
if (message.calls !== 0) {
|
|
18792
|
+
writer.uint32(24).uint64(message.calls);
|
|
18793
|
+
}
|
|
18794
|
+
if (message.countedCalls !== 0) {
|
|
18795
|
+
writer.uint32(32).uint64(message.countedCalls);
|
|
18796
|
+
}
|
|
18797
|
+
if (message.zeroThinkingCalls !== 0) {
|
|
18798
|
+
writer.uint32(40).uint64(message.zeroThinkingCalls);
|
|
18799
|
+
}
|
|
18800
|
+
if (message.medianPerCall !== undefined) {
|
|
18801
|
+
writer.uint32(48).uint64(message.medianPerCall);
|
|
18802
|
+
}
|
|
18803
|
+
if (message.p90PerCall !== undefined) {
|
|
18804
|
+
writer.uint32(56).uint64(message.p90PerCall);
|
|
18805
|
+
}
|
|
18806
|
+
if (message.countedTurns !== 0) {
|
|
18807
|
+
writer.uint32(64).uint64(message.countedTurns);
|
|
18808
|
+
}
|
|
18809
|
+
if (message.medianPerTurn !== undefined) {
|
|
18810
|
+
writer.uint32(72).uint64(message.medianPerTurn);
|
|
18811
|
+
}
|
|
18812
|
+
for (const v of message.weeks) {
|
|
18813
|
+
ModelReasoningWeek.encode(v!, writer.uint32(82).fork()).join();
|
|
18814
|
+
}
|
|
18815
|
+
return writer;
|
|
18816
|
+
},
|
|
18817
|
+
|
|
18818
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ModelReasoning {
|
|
18819
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
18820
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
18821
|
+
if (previousRecursionDepth >= 100) {
|
|
18822
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
18823
|
+
}
|
|
18824
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
18825
|
+
try {
|
|
18826
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
18827
|
+
const message = createBaseModelReasoning();
|
|
18828
|
+
while (reader.pos < end) {
|
|
18829
|
+
const tag = reader.uint32();
|
|
18830
|
+
switch (tag >>> 3) {
|
|
18831
|
+
case 1: {
|
|
18832
|
+
if (tag !== 10) {
|
|
18833
|
+
break;
|
|
18834
|
+
}
|
|
18835
|
+
|
|
18836
|
+
message.modelKey = reader.string();
|
|
18837
|
+
continue;
|
|
18838
|
+
}
|
|
18839
|
+
case 2: {
|
|
18840
|
+
if (tag !== 18) {
|
|
18841
|
+
break;
|
|
18842
|
+
}
|
|
18843
|
+
|
|
18844
|
+
message.effortKey = reader.string();
|
|
18845
|
+
continue;
|
|
18846
|
+
}
|
|
18847
|
+
case 3: {
|
|
18848
|
+
if (tag !== 24) {
|
|
18849
|
+
break;
|
|
18850
|
+
}
|
|
18851
|
+
|
|
18852
|
+
message.calls = longToNumber(reader.uint64());
|
|
18853
|
+
continue;
|
|
18854
|
+
}
|
|
18855
|
+
case 4: {
|
|
18856
|
+
if (tag !== 32) {
|
|
18857
|
+
break;
|
|
18858
|
+
}
|
|
18859
|
+
|
|
18860
|
+
message.countedCalls = longToNumber(reader.uint64());
|
|
18861
|
+
continue;
|
|
18862
|
+
}
|
|
18863
|
+
case 5: {
|
|
18864
|
+
if (tag !== 40) {
|
|
18865
|
+
break;
|
|
18866
|
+
}
|
|
18867
|
+
|
|
18868
|
+
message.zeroThinkingCalls = longToNumber(reader.uint64());
|
|
18869
|
+
continue;
|
|
18870
|
+
}
|
|
18871
|
+
case 6: {
|
|
18872
|
+
if (tag !== 48) {
|
|
18873
|
+
break;
|
|
18874
|
+
}
|
|
18875
|
+
|
|
18876
|
+
message.medianPerCall = longToNumber(reader.uint64());
|
|
18877
|
+
continue;
|
|
18878
|
+
}
|
|
18879
|
+
case 7: {
|
|
18880
|
+
if (tag !== 56) {
|
|
18881
|
+
break;
|
|
18882
|
+
}
|
|
18883
|
+
|
|
18884
|
+
message.p90PerCall = longToNumber(reader.uint64());
|
|
18885
|
+
continue;
|
|
18886
|
+
}
|
|
18887
|
+
case 8: {
|
|
18888
|
+
if (tag !== 64) {
|
|
18889
|
+
break;
|
|
18890
|
+
}
|
|
18891
|
+
|
|
18892
|
+
message.countedTurns = longToNumber(reader.uint64());
|
|
18893
|
+
continue;
|
|
18894
|
+
}
|
|
18895
|
+
case 9: {
|
|
18896
|
+
if (tag !== 72) {
|
|
18897
|
+
break;
|
|
18898
|
+
}
|
|
18899
|
+
|
|
18900
|
+
message.medianPerTurn = longToNumber(reader.uint64());
|
|
18901
|
+
continue;
|
|
18902
|
+
}
|
|
18903
|
+
case 10: {
|
|
18904
|
+
if (tag !== 82) {
|
|
18905
|
+
break;
|
|
18906
|
+
}
|
|
18907
|
+
|
|
18908
|
+
message.weeks.push(ModelReasoningWeek.decode(reader, reader.uint32()));
|
|
18909
|
+
continue;
|
|
18910
|
+
}
|
|
18911
|
+
}
|
|
18912
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
18913
|
+
break;
|
|
18914
|
+
}
|
|
18915
|
+
reader.skip(tag & 7);
|
|
18916
|
+
}
|
|
18917
|
+
return message;
|
|
18918
|
+
} finally {
|
|
18919
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
18920
|
+
}
|
|
18921
|
+
},
|
|
18922
|
+
|
|
18923
|
+
fromJSON(object: any): ModelReasoning {
|
|
18924
|
+
return {
|
|
18925
|
+
modelKey: isSet(object.modelKey)
|
|
18926
|
+
? globalThis.String(object.modelKey)
|
|
18927
|
+
: isSet(object.model_key)
|
|
18928
|
+
? globalThis.String(object.model_key)
|
|
18929
|
+
: "",
|
|
18930
|
+
effortKey: isSet(object.effortKey)
|
|
18931
|
+
? globalThis.String(object.effortKey)
|
|
18932
|
+
: isSet(object.effort_key)
|
|
18933
|
+
? globalThis.String(object.effort_key)
|
|
18934
|
+
: "",
|
|
18935
|
+
calls: isSet(object.calls) ? globalThis.Number(object.calls) : 0,
|
|
18936
|
+
countedCalls: isSet(object.countedCalls)
|
|
18937
|
+
? globalThis.Number(object.countedCalls)
|
|
18938
|
+
: isSet(object.counted_calls)
|
|
18939
|
+
? globalThis.Number(object.counted_calls)
|
|
18940
|
+
: 0,
|
|
18941
|
+
zeroThinkingCalls: isSet(object.zeroThinkingCalls)
|
|
18942
|
+
? globalThis.Number(object.zeroThinkingCalls)
|
|
18943
|
+
: isSet(object.zero_thinking_calls)
|
|
18944
|
+
? globalThis.Number(object.zero_thinking_calls)
|
|
18945
|
+
: 0,
|
|
18946
|
+
medianPerCall: isSet(object.medianPerCall)
|
|
18947
|
+
? globalThis.Number(object.medianPerCall)
|
|
18948
|
+
: isSet(object.median_per_call)
|
|
18949
|
+
? globalThis.Number(object.median_per_call)
|
|
18950
|
+
: undefined,
|
|
18951
|
+
p90PerCall: isSet(object.p90PerCall)
|
|
18952
|
+
? globalThis.Number(object.p90PerCall)
|
|
18953
|
+
: isSet(object.p90_per_call)
|
|
18954
|
+
? globalThis.Number(object.p90_per_call)
|
|
18955
|
+
: undefined,
|
|
18956
|
+
countedTurns: isSet(object.countedTurns)
|
|
18957
|
+
? globalThis.Number(object.countedTurns)
|
|
18958
|
+
: isSet(object.counted_turns)
|
|
18959
|
+
? globalThis.Number(object.counted_turns)
|
|
18960
|
+
: 0,
|
|
18961
|
+
medianPerTurn: isSet(object.medianPerTurn)
|
|
18962
|
+
? globalThis.Number(object.medianPerTurn)
|
|
18963
|
+
: isSet(object.median_per_turn)
|
|
18964
|
+
? globalThis.Number(object.median_per_turn)
|
|
18965
|
+
: undefined,
|
|
18966
|
+
weeks: globalThis.Array.isArray(object?.weeks)
|
|
18967
|
+
? object.weeks.map((e: any) => ModelReasoningWeek.fromJSON(e))
|
|
18968
|
+
: [],
|
|
18969
|
+
};
|
|
18970
|
+
},
|
|
18971
|
+
|
|
18972
|
+
toJSON(message: ModelReasoning): unknown {
|
|
18973
|
+
const obj: any = {};
|
|
18974
|
+
if (message.modelKey !== "") {
|
|
18975
|
+
obj.modelKey = message.modelKey;
|
|
18976
|
+
}
|
|
18977
|
+
if (message.effortKey !== "") {
|
|
18978
|
+
obj.effortKey = message.effortKey;
|
|
18979
|
+
}
|
|
18980
|
+
if (message.calls !== 0) {
|
|
18981
|
+
obj.calls = Math.round(message.calls);
|
|
18982
|
+
}
|
|
18983
|
+
if (message.countedCalls !== 0) {
|
|
18984
|
+
obj.countedCalls = Math.round(message.countedCalls);
|
|
18985
|
+
}
|
|
18986
|
+
if (message.zeroThinkingCalls !== 0) {
|
|
18987
|
+
obj.zeroThinkingCalls = Math.round(message.zeroThinkingCalls);
|
|
18988
|
+
}
|
|
18989
|
+
if (message.medianPerCall !== undefined) {
|
|
18990
|
+
obj.medianPerCall = Math.round(message.medianPerCall);
|
|
18991
|
+
}
|
|
18992
|
+
if (message.p90PerCall !== undefined) {
|
|
18993
|
+
obj.p90PerCall = Math.round(message.p90PerCall);
|
|
18994
|
+
}
|
|
18995
|
+
if (message.countedTurns !== 0) {
|
|
18996
|
+
obj.countedTurns = Math.round(message.countedTurns);
|
|
18997
|
+
}
|
|
18998
|
+
if (message.medianPerTurn !== undefined) {
|
|
18999
|
+
obj.medianPerTurn = Math.round(message.medianPerTurn);
|
|
19000
|
+
}
|
|
19001
|
+
if (message.weeks?.length) {
|
|
19002
|
+
obj.weeks = message.weeks.map((e) => ModelReasoningWeek.toJSON(e));
|
|
19003
|
+
}
|
|
19004
|
+
return obj;
|
|
19005
|
+
},
|
|
19006
|
+
|
|
19007
|
+
create<I extends Exact<DeepPartial<ModelReasoning>, I>>(base?: I): ModelReasoning {
|
|
19008
|
+
return ModelReasoning.fromPartial(base ?? ({} as any));
|
|
19009
|
+
},
|
|
19010
|
+
fromPartial<I extends Exact<DeepPartial<ModelReasoning>, I>>(object: I): ModelReasoning {
|
|
19011
|
+
const message = createBaseModelReasoning();
|
|
19012
|
+
message.modelKey = object.modelKey ?? "";
|
|
19013
|
+
message.effortKey = object.effortKey ?? "";
|
|
19014
|
+
message.calls = object.calls ?? 0;
|
|
19015
|
+
message.countedCalls = object.countedCalls ?? 0;
|
|
19016
|
+
message.zeroThinkingCalls = object.zeroThinkingCalls ?? 0;
|
|
19017
|
+
message.medianPerCall = object.medianPerCall ?? undefined;
|
|
19018
|
+
message.p90PerCall = object.p90PerCall ?? undefined;
|
|
19019
|
+
message.countedTurns = object.countedTurns ?? 0;
|
|
19020
|
+
message.medianPerTurn = object.medianPerTurn ?? undefined;
|
|
19021
|
+
message.weeks = object.weeks?.map((e) => ModelReasoningWeek.fromPartial(e)) || [];
|
|
19022
|
+
return message;
|
|
19023
|
+
},
|
|
19024
|
+
};
|
|
19025
|
+
|
|
19026
|
+
function createBaseModelReasoningWeek(): ModelReasoningWeek {
|
|
19027
|
+
return {
|
|
19028
|
+
weekStart: undefined,
|
|
19029
|
+
countedCalls: 0,
|
|
19030
|
+
medianPerCall: undefined,
|
|
19031
|
+
medianCiLow: undefined,
|
|
19032
|
+
medianCiHigh: undefined,
|
|
19033
|
+
baseline: undefined,
|
|
19034
|
+
};
|
|
19035
|
+
}
|
|
19036
|
+
|
|
19037
|
+
export const ModelReasoningWeek: MessageFns<ModelReasoningWeek> = {
|
|
19038
|
+
encode(message: ModelReasoningWeek, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19039
|
+
if (message.weekStart !== undefined) {
|
|
19040
|
+
Timestamp.encode(toTimestamp(message.weekStart), writer.uint32(10).fork()).join();
|
|
19041
|
+
}
|
|
19042
|
+
if (message.countedCalls !== 0) {
|
|
19043
|
+
writer.uint32(16).uint64(message.countedCalls);
|
|
19044
|
+
}
|
|
19045
|
+
if (message.medianPerCall !== undefined) {
|
|
19046
|
+
writer.uint32(24).uint64(message.medianPerCall);
|
|
19047
|
+
}
|
|
19048
|
+
if (message.medianCiLow !== undefined) {
|
|
19049
|
+
writer.uint32(32).uint64(message.medianCiLow);
|
|
19050
|
+
}
|
|
19051
|
+
if (message.medianCiHigh !== undefined) {
|
|
19052
|
+
writer.uint32(40).uint64(message.medianCiHigh);
|
|
19053
|
+
}
|
|
19054
|
+
if (message.baseline !== undefined) {
|
|
19055
|
+
ModelReasoningBaseline.encode(message.baseline, writer.uint32(50).fork()).join();
|
|
19056
|
+
}
|
|
19057
|
+
return writer;
|
|
19058
|
+
},
|
|
19059
|
+
|
|
19060
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ModelReasoningWeek {
|
|
19061
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19062
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19063
|
+
if (previousRecursionDepth >= 100) {
|
|
19064
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19065
|
+
}
|
|
19066
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19067
|
+
try {
|
|
19068
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19069
|
+
const message = createBaseModelReasoningWeek();
|
|
19070
|
+
while (reader.pos < end) {
|
|
19071
|
+
const tag = reader.uint32();
|
|
19072
|
+
switch (tag >>> 3) {
|
|
19073
|
+
case 1: {
|
|
19074
|
+
if (tag !== 10) {
|
|
19075
|
+
break;
|
|
19076
|
+
}
|
|
19077
|
+
|
|
19078
|
+
message.weekStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
19079
|
+
continue;
|
|
19080
|
+
}
|
|
19081
|
+
case 2: {
|
|
19082
|
+
if (tag !== 16) {
|
|
19083
|
+
break;
|
|
19084
|
+
}
|
|
19085
|
+
|
|
19086
|
+
message.countedCalls = longToNumber(reader.uint64());
|
|
19087
|
+
continue;
|
|
19088
|
+
}
|
|
19089
|
+
case 3: {
|
|
19090
|
+
if (tag !== 24) {
|
|
19091
|
+
break;
|
|
19092
|
+
}
|
|
19093
|
+
|
|
19094
|
+
message.medianPerCall = longToNumber(reader.uint64());
|
|
19095
|
+
continue;
|
|
19096
|
+
}
|
|
19097
|
+
case 4: {
|
|
19098
|
+
if (tag !== 32) {
|
|
19099
|
+
break;
|
|
19100
|
+
}
|
|
19101
|
+
|
|
19102
|
+
message.medianCiLow = longToNumber(reader.uint64());
|
|
19103
|
+
continue;
|
|
19104
|
+
}
|
|
19105
|
+
case 5: {
|
|
19106
|
+
if (tag !== 40) {
|
|
19107
|
+
break;
|
|
19108
|
+
}
|
|
19109
|
+
|
|
19110
|
+
message.medianCiHigh = longToNumber(reader.uint64());
|
|
19111
|
+
continue;
|
|
19112
|
+
}
|
|
19113
|
+
case 6: {
|
|
19114
|
+
if (tag !== 50) {
|
|
19115
|
+
break;
|
|
19116
|
+
}
|
|
19117
|
+
|
|
19118
|
+
message.baseline = ModelReasoningBaseline.decode(reader, reader.uint32());
|
|
19119
|
+
continue;
|
|
19120
|
+
}
|
|
19121
|
+
}
|
|
19122
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19123
|
+
break;
|
|
19124
|
+
}
|
|
19125
|
+
reader.skip(tag & 7);
|
|
19126
|
+
}
|
|
19127
|
+
return message;
|
|
19128
|
+
} finally {
|
|
19129
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19130
|
+
}
|
|
19131
|
+
},
|
|
19132
|
+
|
|
19133
|
+
fromJSON(object: any): ModelReasoningWeek {
|
|
19134
|
+
return {
|
|
19135
|
+
weekStart: isSet(object.weekStart)
|
|
19136
|
+
? fromJsonTimestamp(object.weekStart)
|
|
19137
|
+
: isSet(object.week_start)
|
|
19138
|
+
? fromJsonTimestamp(object.week_start)
|
|
19139
|
+
: undefined,
|
|
19140
|
+
countedCalls: isSet(object.countedCalls)
|
|
19141
|
+
? globalThis.Number(object.countedCalls)
|
|
19142
|
+
: isSet(object.counted_calls)
|
|
19143
|
+
? globalThis.Number(object.counted_calls)
|
|
19144
|
+
: 0,
|
|
19145
|
+
medianPerCall: isSet(object.medianPerCall)
|
|
19146
|
+
? globalThis.Number(object.medianPerCall)
|
|
19147
|
+
: isSet(object.median_per_call)
|
|
19148
|
+
? globalThis.Number(object.median_per_call)
|
|
19149
|
+
: undefined,
|
|
19150
|
+
medianCiLow: isSet(object.medianCiLow)
|
|
19151
|
+
? globalThis.Number(object.medianCiLow)
|
|
19152
|
+
: isSet(object.median_ci_low)
|
|
19153
|
+
? globalThis.Number(object.median_ci_low)
|
|
19154
|
+
: undefined,
|
|
19155
|
+
medianCiHigh: isSet(object.medianCiHigh)
|
|
19156
|
+
? globalThis.Number(object.medianCiHigh)
|
|
19157
|
+
: isSet(object.median_ci_high)
|
|
19158
|
+
? globalThis.Number(object.median_ci_high)
|
|
19159
|
+
: undefined,
|
|
19160
|
+
baseline: isSet(object.baseline) ? ModelReasoningBaseline.fromJSON(object.baseline) : undefined,
|
|
19161
|
+
};
|
|
19162
|
+
},
|
|
19163
|
+
|
|
19164
|
+
toJSON(message: ModelReasoningWeek): unknown {
|
|
19165
|
+
const obj: any = {};
|
|
19166
|
+
if (message.weekStart !== undefined) {
|
|
19167
|
+
obj.weekStart = message.weekStart.toISOString();
|
|
19168
|
+
}
|
|
19169
|
+
if (message.countedCalls !== 0) {
|
|
19170
|
+
obj.countedCalls = Math.round(message.countedCalls);
|
|
19171
|
+
}
|
|
19172
|
+
if (message.medianPerCall !== undefined) {
|
|
19173
|
+
obj.medianPerCall = Math.round(message.medianPerCall);
|
|
19174
|
+
}
|
|
19175
|
+
if (message.medianCiLow !== undefined) {
|
|
19176
|
+
obj.medianCiLow = Math.round(message.medianCiLow);
|
|
19177
|
+
}
|
|
19178
|
+
if (message.medianCiHigh !== undefined) {
|
|
19179
|
+
obj.medianCiHigh = Math.round(message.medianCiHigh);
|
|
19180
|
+
}
|
|
19181
|
+
if (message.baseline !== undefined) {
|
|
19182
|
+
obj.baseline = ModelReasoningBaseline.toJSON(message.baseline);
|
|
19183
|
+
}
|
|
19184
|
+
return obj;
|
|
19185
|
+
},
|
|
19186
|
+
|
|
19187
|
+
create<I extends Exact<DeepPartial<ModelReasoningWeek>, I>>(base?: I): ModelReasoningWeek {
|
|
19188
|
+
return ModelReasoningWeek.fromPartial(base ?? ({} as any));
|
|
19189
|
+
},
|
|
19190
|
+
fromPartial<I extends Exact<DeepPartial<ModelReasoningWeek>, I>>(object: I): ModelReasoningWeek {
|
|
19191
|
+
const message = createBaseModelReasoningWeek();
|
|
19192
|
+
message.weekStart = object.weekStart ?? undefined;
|
|
19193
|
+
message.countedCalls = object.countedCalls ?? 0;
|
|
19194
|
+
message.medianPerCall = object.medianPerCall ?? undefined;
|
|
19195
|
+
message.medianCiLow = object.medianCiLow ?? undefined;
|
|
19196
|
+
message.medianCiHigh = object.medianCiHigh ?? undefined;
|
|
19197
|
+
message.baseline = (object.baseline !== undefined && object.baseline !== null)
|
|
19198
|
+
? ModelReasoningBaseline.fromPartial(object.baseline)
|
|
19199
|
+
: undefined;
|
|
19200
|
+
return message;
|
|
19201
|
+
},
|
|
19202
|
+
};
|
|
19203
|
+
|
|
19204
|
+
function createBaseModelReasoningBaseline(): ModelReasoningBaseline {
|
|
19205
|
+
return { countedCalls: 0, median: undefined, ciLow: undefined, ciHigh: undefined };
|
|
19206
|
+
}
|
|
19207
|
+
|
|
19208
|
+
export const ModelReasoningBaseline: MessageFns<ModelReasoningBaseline> = {
|
|
19209
|
+
encode(message: ModelReasoningBaseline, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19210
|
+
if (message.countedCalls !== 0) {
|
|
19211
|
+
writer.uint32(8).uint64(message.countedCalls);
|
|
19212
|
+
}
|
|
19213
|
+
if (message.median !== undefined) {
|
|
19214
|
+
writer.uint32(16).uint64(message.median);
|
|
19215
|
+
}
|
|
19216
|
+
if (message.ciLow !== undefined) {
|
|
19217
|
+
writer.uint32(24).uint64(message.ciLow);
|
|
19218
|
+
}
|
|
19219
|
+
if (message.ciHigh !== undefined) {
|
|
19220
|
+
writer.uint32(32).uint64(message.ciHigh);
|
|
19221
|
+
}
|
|
19222
|
+
return writer;
|
|
19223
|
+
},
|
|
19224
|
+
|
|
19225
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ModelReasoningBaseline {
|
|
19226
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19227
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19228
|
+
if (previousRecursionDepth >= 100) {
|
|
19229
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19230
|
+
}
|
|
19231
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19232
|
+
try {
|
|
19233
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19234
|
+
const message = createBaseModelReasoningBaseline();
|
|
19235
|
+
while (reader.pos < end) {
|
|
19236
|
+
const tag = reader.uint32();
|
|
19237
|
+
switch (tag >>> 3) {
|
|
19238
|
+
case 1: {
|
|
19239
|
+
if (tag !== 8) {
|
|
19240
|
+
break;
|
|
19241
|
+
}
|
|
19242
|
+
|
|
19243
|
+
message.countedCalls = longToNumber(reader.uint64());
|
|
19244
|
+
continue;
|
|
19245
|
+
}
|
|
19246
|
+
case 2: {
|
|
19247
|
+
if (tag !== 16) {
|
|
19248
|
+
break;
|
|
19249
|
+
}
|
|
19250
|
+
|
|
19251
|
+
message.median = longToNumber(reader.uint64());
|
|
19252
|
+
continue;
|
|
19253
|
+
}
|
|
19254
|
+
case 3: {
|
|
19255
|
+
if (tag !== 24) {
|
|
19256
|
+
break;
|
|
19257
|
+
}
|
|
19258
|
+
|
|
19259
|
+
message.ciLow = longToNumber(reader.uint64());
|
|
19260
|
+
continue;
|
|
19261
|
+
}
|
|
19262
|
+
case 4: {
|
|
19263
|
+
if (tag !== 32) {
|
|
19264
|
+
break;
|
|
19265
|
+
}
|
|
19266
|
+
|
|
19267
|
+
message.ciHigh = longToNumber(reader.uint64());
|
|
19268
|
+
continue;
|
|
19269
|
+
}
|
|
19270
|
+
}
|
|
19271
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19272
|
+
break;
|
|
19273
|
+
}
|
|
19274
|
+
reader.skip(tag & 7);
|
|
19275
|
+
}
|
|
19276
|
+
return message;
|
|
19277
|
+
} finally {
|
|
19278
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19279
|
+
}
|
|
19280
|
+
},
|
|
19281
|
+
|
|
19282
|
+
fromJSON(object: any): ModelReasoningBaseline {
|
|
19283
|
+
return {
|
|
19284
|
+
countedCalls: isSet(object.countedCalls)
|
|
19285
|
+
? globalThis.Number(object.countedCalls)
|
|
19286
|
+
: isSet(object.counted_calls)
|
|
19287
|
+
? globalThis.Number(object.counted_calls)
|
|
19288
|
+
: 0,
|
|
19289
|
+
median: isSet(object.median) ? globalThis.Number(object.median) : undefined,
|
|
19290
|
+
ciLow: isSet(object.ciLow)
|
|
19291
|
+
? globalThis.Number(object.ciLow)
|
|
19292
|
+
: isSet(object.ci_low)
|
|
19293
|
+
? globalThis.Number(object.ci_low)
|
|
19294
|
+
: undefined,
|
|
19295
|
+
ciHigh: isSet(object.ciHigh)
|
|
19296
|
+
? globalThis.Number(object.ciHigh)
|
|
19297
|
+
: isSet(object.ci_high)
|
|
19298
|
+
? globalThis.Number(object.ci_high)
|
|
19299
|
+
: undefined,
|
|
19300
|
+
};
|
|
19301
|
+
},
|
|
19302
|
+
|
|
19303
|
+
toJSON(message: ModelReasoningBaseline): unknown {
|
|
19304
|
+
const obj: any = {};
|
|
19305
|
+
if (message.countedCalls !== 0) {
|
|
19306
|
+
obj.countedCalls = Math.round(message.countedCalls);
|
|
19307
|
+
}
|
|
19308
|
+
if (message.median !== undefined) {
|
|
19309
|
+
obj.median = Math.round(message.median);
|
|
19310
|
+
}
|
|
19311
|
+
if (message.ciLow !== undefined) {
|
|
19312
|
+
obj.ciLow = Math.round(message.ciLow);
|
|
19313
|
+
}
|
|
19314
|
+
if (message.ciHigh !== undefined) {
|
|
19315
|
+
obj.ciHigh = Math.round(message.ciHigh);
|
|
19316
|
+
}
|
|
19317
|
+
return obj;
|
|
19318
|
+
},
|
|
19319
|
+
|
|
19320
|
+
create<I extends Exact<DeepPartial<ModelReasoningBaseline>, I>>(base?: I): ModelReasoningBaseline {
|
|
19321
|
+
return ModelReasoningBaseline.fromPartial(base ?? ({} as any));
|
|
19322
|
+
},
|
|
19323
|
+
fromPartial<I extends Exact<DeepPartial<ModelReasoningBaseline>, I>>(object: I): ModelReasoningBaseline {
|
|
19324
|
+
const message = createBaseModelReasoningBaseline();
|
|
19325
|
+
message.countedCalls = object.countedCalls ?? 0;
|
|
19326
|
+
message.median = object.median ?? undefined;
|
|
19327
|
+
message.ciLow = object.ciLow ?? undefined;
|
|
19328
|
+
message.ciHigh = object.ciHigh ?? undefined;
|
|
19329
|
+
return message;
|
|
19330
|
+
},
|
|
19331
|
+
};
|
|
19332
|
+
|
|
19333
|
+
function createBaseReasoningCoverage(): ReasoningCoverage {
|
|
19334
|
+
return { calls: 0, countedCalls: 0, sourceSystems: [] };
|
|
19335
|
+
}
|
|
19336
|
+
|
|
19337
|
+
export const ReasoningCoverage: MessageFns<ReasoningCoverage> = {
|
|
19338
|
+
encode(message: ReasoningCoverage, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19339
|
+
if (message.calls !== 0) {
|
|
19340
|
+
writer.uint32(8).uint64(message.calls);
|
|
19341
|
+
}
|
|
19342
|
+
if (message.countedCalls !== 0) {
|
|
19343
|
+
writer.uint32(16).uint64(message.countedCalls);
|
|
19344
|
+
}
|
|
19345
|
+
for (const v of message.sourceSystems) {
|
|
19346
|
+
writer.uint32(26).string(v!);
|
|
19347
|
+
}
|
|
19348
|
+
return writer;
|
|
19349
|
+
},
|
|
19350
|
+
|
|
19351
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ReasoningCoverage {
|
|
19352
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19353
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19354
|
+
if (previousRecursionDepth >= 100) {
|
|
19355
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19356
|
+
}
|
|
19357
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19358
|
+
try {
|
|
19359
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19360
|
+
const message = createBaseReasoningCoverage();
|
|
19361
|
+
while (reader.pos < end) {
|
|
19362
|
+
const tag = reader.uint32();
|
|
19363
|
+
switch (tag >>> 3) {
|
|
19364
|
+
case 1: {
|
|
19365
|
+
if (tag !== 8) {
|
|
19366
|
+
break;
|
|
19367
|
+
}
|
|
19368
|
+
|
|
19369
|
+
message.calls = longToNumber(reader.uint64());
|
|
19370
|
+
continue;
|
|
19371
|
+
}
|
|
19372
|
+
case 2: {
|
|
19373
|
+
if (tag !== 16) {
|
|
19374
|
+
break;
|
|
19375
|
+
}
|
|
19376
|
+
|
|
19377
|
+
message.countedCalls = longToNumber(reader.uint64());
|
|
19378
|
+
continue;
|
|
19379
|
+
}
|
|
19380
|
+
case 3: {
|
|
19381
|
+
if (tag !== 26) {
|
|
19382
|
+
break;
|
|
19383
|
+
}
|
|
19384
|
+
|
|
19385
|
+
message.sourceSystems.push(reader.string());
|
|
19386
|
+
continue;
|
|
19387
|
+
}
|
|
19388
|
+
}
|
|
19389
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19390
|
+
break;
|
|
19391
|
+
}
|
|
19392
|
+
reader.skip(tag & 7);
|
|
19393
|
+
}
|
|
19394
|
+
return message;
|
|
19395
|
+
} finally {
|
|
19396
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19397
|
+
}
|
|
19398
|
+
},
|
|
19399
|
+
|
|
19400
|
+
fromJSON(object: any): ReasoningCoverage {
|
|
19401
|
+
return {
|
|
19402
|
+
calls: isSet(object.calls) ? globalThis.Number(object.calls) : 0,
|
|
19403
|
+
countedCalls: isSet(object.countedCalls)
|
|
19404
|
+
? globalThis.Number(object.countedCalls)
|
|
19405
|
+
: isSet(object.counted_calls)
|
|
19406
|
+
? globalThis.Number(object.counted_calls)
|
|
19407
|
+
: 0,
|
|
19408
|
+
sourceSystems: globalThis.Array.isArray(object?.sourceSystems)
|
|
19409
|
+
? object.sourceSystems.map((e: any) => globalThis.String(e))
|
|
19410
|
+
: globalThis.Array.isArray(object?.source_systems)
|
|
19411
|
+
? object.source_systems.map((e: any) => globalThis.String(e))
|
|
19412
|
+
: [],
|
|
19413
|
+
};
|
|
19414
|
+
},
|
|
19415
|
+
|
|
19416
|
+
toJSON(message: ReasoningCoverage): unknown {
|
|
19417
|
+
const obj: any = {};
|
|
19418
|
+
if (message.calls !== 0) {
|
|
19419
|
+
obj.calls = Math.round(message.calls);
|
|
19420
|
+
}
|
|
19421
|
+
if (message.countedCalls !== 0) {
|
|
19422
|
+
obj.countedCalls = Math.round(message.countedCalls);
|
|
19423
|
+
}
|
|
19424
|
+
if (message.sourceSystems?.length) {
|
|
19425
|
+
obj.sourceSystems = message.sourceSystems;
|
|
19426
|
+
}
|
|
19427
|
+
return obj;
|
|
19428
|
+
},
|
|
19429
|
+
|
|
19430
|
+
create<I extends Exact<DeepPartial<ReasoningCoverage>, I>>(base?: I): ReasoningCoverage {
|
|
19431
|
+
return ReasoningCoverage.fromPartial(base ?? ({} as any));
|
|
19432
|
+
},
|
|
19433
|
+
fromPartial<I extends Exact<DeepPartial<ReasoningCoverage>, I>>(object: I): ReasoningCoverage {
|
|
19434
|
+
const message = createBaseReasoningCoverage();
|
|
19435
|
+
message.calls = object.calls ?? 0;
|
|
19436
|
+
message.countedCalls = object.countedCalls ?? 0;
|
|
19437
|
+
message.sourceSystems = object.sourceSystems?.map((e) => e) || [];
|
|
19438
|
+
return message;
|
|
19439
|
+
},
|
|
19440
|
+
};
|
|
19441
|
+
|
|
19442
|
+
function createBaseReasoningServedModels(): ReasoningServedModels {
|
|
19443
|
+
return { servedCalls: 0, modelMismatchCalls: 0, serviceTiers: [], inferenceGeos: [] };
|
|
19444
|
+
}
|
|
19445
|
+
|
|
19446
|
+
export const ReasoningServedModels: MessageFns<ReasoningServedModels> = {
|
|
19447
|
+
encode(message: ReasoningServedModels, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19448
|
+
if (message.servedCalls !== 0) {
|
|
19449
|
+
writer.uint32(8).uint64(message.servedCalls);
|
|
19450
|
+
}
|
|
19451
|
+
if (message.modelMismatchCalls !== 0) {
|
|
19452
|
+
writer.uint32(16).uint64(message.modelMismatchCalls);
|
|
19453
|
+
}
|
|
19454
|
+
for (const v of message.serviceTiers) {
|
|
19455
|
+
LabelCount.encode(v!, writer.uint32(26).fork()).join();
|
|
19456
|
+
}
|
|
19457
|
+
for (const v of message.inferenceGeos) {
|
|
19458
|
+
LabelCount.encode(v!, writer.uint32(34).fork()).join();
|
|
19459
|
+
}
|
|
19460
|
+
return writer;
|
|
19461
|
+
},
|
|
19462
|
+
|
|
19463
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ReasoningServedModels {
|
|
19464
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19465
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19466
|
+
if (previousRecursionDepth >= 100) {
|
|
19467
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19468
|
+
}
|
|
19469
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19470
|
+
try {
|
|
19471
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19472
|
+
const message = createBaseReasoningServedModels();
|
|
19473
|
+
while (reader.pos < end) {
|
|
19474
|
+
const tag = reader.uint32();
|
|
19475
|
+
switch (tag >>> 3) {
|
|
19476
|
+
case 1: {
|
|
19477
|
+
if (tag !== 8) {
|
|
19478
|
+
break;
|
|
19479
|
+
}
|
|
19480
|
+
|
|
19481
|
+
message.servedCalls = longToNumber(reader.uint64());
|
|
19482
|
+
continue;
|
|
19483
|
+
}
|
|
19484
|
+
case 2: {
|
|
19485
|
+
if (tag !== 16) {
|
|
19486
|
+
break;
|
|
19487
|
+
}
|
|
19488
|
+
|
|
19489
|
+
message.modelMismatchCalls = longToNumber(reader.uint64());
|
|
19490
|
+
continue;
|
|
19491
|
+
}
|
|
19492
|
+
case 3: {
|
|
19493
|
+
if (tag !== 26) {
|
|
19494
|
+
break;
|
|
19495
|
+
}
|
|
19496
|
+
|
|
19497
|
+
message.serviceTiers.push(LabelCount.decode(reader, reader.uint32()));
|
|
19498
|
+
continue;
|
|
19499
|
+
}
|
|
19500
|
+
case 4: {
|
|
19501
|
+
if (tag !== 34) {
|
|
19502
|
+
break;
|
|
19503
|
+
}
|
|
19504
|
+
|
|
19505
|
+
message.inferenceGeos.push(LabelCount.decode(reader, reader.uint32()));
|
|
19506
|
+
continue;
|
|
19507
|
+
}
|
|
19508
|
+
}
|
|
19509
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19510
|
+
break;
|
|
19511
|
+
}
|
|
19512
|
+
reader.skip(tag & 7);
|
|
19513
|
+
}
|
|
19514
|
+
return message;
|
|
19515
|
+
} finally {
|
|
19516
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19517
|
+
}
|
|
19518
|
+
},
|
|
19519
|
+
|
|
19520
|
+
fromJSON(object: any): ReasoningServedModels {
|
|
19521
|
+
return {
|
|
19522
|
+
servedCalls: isSet(object.servedCalls)
|
|
19523
|
+
? globalThis.Number(object.servedCalls)
|
|
19524
|
+
: isSet(object.served_calls)
|
|
19525
|
+
? globalThis.Number(object.served_calls)
|
|
19526
|
+
: 0,
|
|
19527
|
+
modelMismatchCalls: isSet(object.modelMismatchCalls)
|
|
19528
|
+
? globalThis.Number(object.modelMismatchCalls)
|
|
19529
|
+
: isSet(object.model_mismatch_calls)
|
|
19530
|
+
? globalThis.Number(object.model_mismatch_calls)
|
|
19531
|
+
: 0,
|
|
19532
|
+
serviceTiers: globalThis.Array.isArray(object?.serviceTiers)
|
|
19533
|
+
? object.serviceTiers.map((e: any) => LabelCount.fromJSON(e))
|
|
19534
|
+
: globalThis.Array.isArray(object?.service_tiers)
|
|
19535
|
+
? object.service_tiers.map((e: any) => LabelCount.fromJSON(e))
|
|
19536
|
+
: [],
|
|
19537
|
+
inferenceGeos: globalThis.Array.isArray(object?.inferenceGeos)
|
|
19538
|
+
? object.inferenceGeos.map((e: any) => LabelCount.fromJSON(e))
|
|
19539
|
+
: globalThis.Array.isArray(object?.inference_geos)
|
|
19540
|
+
? object.inference_geos.map((e: any) => LabelCount.fromJSON(e))
|
|
19541
|
+
: [],
|
|
19542
|
+
};
|
|
19543
|
+
},
|
|
19544
|
+
|
|
19545
|
+
toJSON(message: ReasoningServedModels): unknown {
|
|
19546
|
+
const obj: any = {};
|
|
19547
|
+
if (message.servedCalls !== 0) {
|
|
19548
|
+
obj.servedCalls = Math.round(message.servedCalls);
|
|
19549
|
+
}
|
|
19550
|
+
if (message.modelMismatchCalls !== 0) {
|
|
19551
|
+
obj.modelMismatchCalls = Math.round(message.modelMismatchCalls);
|
|
19552
|
+
}
|
|
19553
|
+
if (message.serviceTiers?.length) {
|
|
19554
|
+
obj.serviceTiers = message.serviceTiers.map((e) => LabelCount.toJSON(e));
|
|
19555
|
+
}
|
|
19556
|
+
if (message.inferenceGeos?.length) {
|
|
19557
|
+
obj.inferenceGeos = message.inferenceGeos.map((e) => LabelCount.toJSON(e));
|
|
19558
|
+
}
|
|
19559
|
+
return obj;
|
|
19560
|
+
},
|
|
19561
|
+
|
|
19562
|
+
create<I extends Exact<DeepPartial<ReasoningServedModels>, I>>(base?: I): ReasoningServedModels {
|
|
19563
|
+
return ReasoningServedModels.fromPartial(base ?? ({} as any));
|
|
19564
|
+
},
|
|
19565
|
+
fromPartial<I extends Exact<DeepPartial<ReasoningServedModels>, I>>(object: I): ReasoningServedModels {
|
|
19566
|
+
const message = createBaseReasoningServedModels();
|
|
19567
|
+
message.servedCalls = object.servedCalls ?? 0;
|
|
19568
|
+
message.modelMismatchCalls = object.modelMismatchCalls ?? 0;
|
|
19569
|
+
message.serviceTiers = object.serviceTiers?.map((e) => LabelCount.fromPartial(e)) || [];
|
|
19570
|
+
message.inferenceGeos = object.inferenceGeos?.map((e) => LabelCount.fromPartial(e)) || [];
|
|
19571
|
+
return message;
|
|
19572
|
+
},
|
|
19573
|
+
};
|
|
19574
|
+
|
|
19575
|
+
function createBaseLabelCount(): LabelCount {
|
|
19576
|
+
return { label: "", calls: 0 };
|
|
19577
|
+
}
|
|
19578
|
+
|
|
19579
|
+
export const LabelCount: MessageFns<LabelCount> = {
|
|
19580
|
+
encode(message: LabelCount, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19581
|
+
if (message.label !== "") {
|
|
19582
|
+
writer.uint32(10).string(message.label);
|
|
19583
|
+
}
|
|
19584
|
+
if (message.calls !== 0) {
|
|
19585
|
+
writer.uint32(16).uint64(message.calls);
|
|
19586
|
+
}
|
|
19587
|
+
return writer;
|
|
19588
|
+
},
|
|
19589
|
+
|
|
19590
|
+
decode(input: BinaryReader | Uint8Array, length?: number): LabelCount {
|
|
19591
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19592
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19593
|
+
if (previousRecursionDepth >= 100) {
|
|
19594
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19595
|
+
}
|
|
19596
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19597
|
+
try {
|
|
19598
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19599
|
+
const message = createBaseLabelCount();
|
|
19600
|
+
while (reader.pos < end) {
|
|
19601
|
+
const tag = reader.uint32();
|
|
19602
|
+
switch (tag >>> 3) {
|
|
19603
|
+
case 1: {
|
|
19604
|
+
if (tag !== 10) {
|
|
19605
|
+
break;
|
|
19606
|
+
}
|
|
19607
|
+
|
|
19608
|
+
message.label = reader.string();
|
|
19609
|
+
continue;
|
|
19610
|
+
}
|
|
19611
|
+
case 2: {
|
|
19612
|
+
if (tag !== 16) {
|
|
19613
|
+
break;
|
|
19614
|
+
}
|
|
19615
|
+
|
|
19616
|
+
message.calls = longToNumber(reader.uint64());
|
|
19617
|
+
continue;
|
|
19618
|
+
}
|
|
19619
|
+
}
|
|
19620
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19621
|
+
break;
|
|
19622
|
+
}
|
|
19623
|
+
reader.skip(tag & 7);
|
|
19624
|
+
}
|
|
19625
|
+
return message;
|
|
19626
|
+
} finally {
|
|
19627
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19628
|
+
}
|
|
19629
|
+
},
|
|
19630
|
+
|
|
19631
|
+
fromJSON(object: any): LabelCount {
|
|
19632
|
+
return {
|
|
19633
|
+
label: isSet(object.label) ? globalThis.String(object.label) : "",
|
|
19634
|
+
calls: isSet(object.calls) ? globalThis.Number(object.calls) : 0,
|
|
19635
|
+
};
|
|
19636
|
+
},
|
|
19637
|
+
|
|
19638
|
+
toJSON(message: LabelCount): unknown {
|
|
19639
|
+
const obj: any = {};
|
|
19640
|
+
if (message.label !== "") {
|
|
19641
|
+
obj.label = message.label;
|
|
19642
|
+
}
|
|
19643
|
+
if (message.calls !== 0) {
|
|
19644
|
+
obj.calls = Math.round(message.calls);
|
|
19645
|
+
}
|
|
19646
|
+
return obj;
|
|
19647
|
+
},
|
|
19648
|
+
|
|
19649
|
+
create<I extends Exact<DeepPartial<LabelCount>, I>>(base?: I): LabelCount {
|
|
19650
|
+
return LabelCount.fromPartial(base ?? ({} as any));
|
|
19651
|
+
},
|
|
19652
|
+
fromPartial<I extends Exact<DeepPartial<LabelCount>, I>>(object: I): LabelCount {
|
|
19653
|
+
const message = createBaseLabelCount();
|
|
19654
|
+
message.label = object.label ?? "";
|
|
19655
|
+
message.calls = object.calls ?? 0;
|
|
19656
|
+
return message;
|
|
19657
|
+
},
|
|
19658
|
+
};
|
|
19659
|
+
|
|
19660
|
+
function createBaseModelActivityResponse(): ModelActivityResponse {
|
|
19661
|
+
return { status: undefined, models: [], windowStart: undefined, windowEnd: undefined };
|
|
19662
|
+
}
|
|
19663
|
+
|
|
19664
|
+
export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
|
|
19665
|
+
encode(message: ModelActivityResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19666
|
+
if (message.status !== undefined) {
|
|
19667
|
+
ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
|
|
19668
|
+
}
|
|
19669
|
+
for (const v of message.models) {
|
|
19670
|
+
ModelActivity.encode(v!, writer.uint32(18).fork()).join();
|
|
19671
|
+
}
|
|
19672
|
+
if (message.windowStart !== undefined) {
|
|
19673
|
+
Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(26).fork()).join();
|
|
19674
|
+
}
|
|
19675
|
+
if (message.windowEnd !== undefined) {
|
|
19676
|
+
Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(34).fork()).join();
|
|
19677
|
+
}
|
|
19678
|
+
return writer;
|
|
19679
|
+
},
|
|
19680
|
+
|
|
19681
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ModelActivityResponse {
|
|
19682
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19683
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19684
|
+
if (previousRecursionDepth >= 100) {
|
|
19685
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19686
|
+
}
|
|
19687
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19688
|
+
try {
|
|
19689
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19690
|
+
const message = createBaseModelActivityResponse();
|
|
19691
|
+
while (reader.pos < end) {
|
|
19692
|
+
const tag = reader.uint32();
|
|
19693
|
+
switch (tag >>> 3) {
|
|
19694
|
+
case 1: {
|
|
19695
|
+
if (tag !== 10) {
|
|
19696
|
+
break;
|
|
19697
|
+
}
|
|
19698
|
+
|
|
19699
|
+
message.status = ResponseStatus.decode(reader, reader.uint32());
|
|
19700
|
+
continue;
|
|
19701
|
+
}
|
|
19702
|
+
case 2: {
|
|
19703
|
+
if (tag !== 18) {
|
|
19704
|
+
break;
|
|
19705
|
+
}
|
|
19706
|
+
|
|
19707
|
+
message.models.push(ModelActivity.decode(reader, reader.uint32()));
|
|
19708
|
+
continue;
|
|
19709
|
+
}
|
|
19710
|
+
case 3: {
|
|
19711
|
+
if (tag !== 26) {
|
|
19712
|
+
break;
|
|
19713
|
+
}
|
|
19714
|
+
|
|
19715
|
+
message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
19716
|
+
continue;
|
|
19717
|
+
}
|
|
19718
|
+
case 4: {
|
|
19719
|
+
if (tag !== 34) {
|
|
19720
|
+
break;
|
|
19721
|
+
}
|
|
19722
|
+
|
|
19723
|
+
message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
|
|
19724
|
+
continue;
|
|
19725
|
+
}
|
|
19726
|
+
}
|
|
19727
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
19728
|
+
break;
|
|
19729
|
+
}
|
|
19730
|
+
reader.skip(tag & 7);
|
|
19731
|
+
}
|
|
19732
|
+
return message;
|
|
19733
|
+
} finally {
|
|
19734
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
|
|
19735
|
+
}
|
|
19736
|
+
},
|
|
19737
|
+
|
|
19738
|
+
fromJSON(object: any): ModelActivityResponse {
|
|
19739
|
+
return {
|
|
19740
|
+
status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
|
|
19741
|
+
models: globalThis.Array.isArray(object?.models) ? object.models.map((e: any) => ModelActivity.fromJSON(e)) : [],
|
|
19742
|
+
windowStart: isSet(object.windowStart)
|
|
19743
|
+
? fromJsonTimestamp(object.windowStart)
|
|
19744
|
+
: isSet(object.window_start)
|
|
19745
|
+
? fromJsonTimestamp(object.window_start)
|
|
19746
|
+
: undefined,
|
|
19747
|
+
windowEnd: isSet(object.windowEnd)
|
|
19748
|
+
? fromJsonTimestamp(object.windowEnd)
|
|
19749
|
+
: isSet(object.window_end)
|
|
19750
|
+
? fromJsonTimestamp(object.window_end)
|
|
19751
|
+
: undefined,
|
|
19752
|
+
};
|
|
19753
|
+
},
|
|
19754
|
+
|
|
19755
|
+
toJSON(message: ModelActivityResponse): unknown {
|
|
19756
|
+
const obj: any = {};
|
|
19757
|
+
if (message.status !== undefined) {
|
|
19758
|
+
obj.status = ResponseStatus.toJSON(message.status);
|
|
19759
|
+
}
|
|
19760
|
+
if (message.models?.length) {
|
|
19761
|
+
obj.models = message.models.map((e) => ModelActivity.toJSON(e));
|
|
19762
|
+
}
|
|
19763
|
+
if (message.windowStart !== undefined) {
|
|
19764
|
+
obj.windowStart = message.windowStart.toISOString();
|
|
19765
|
+
}
|
|
19766
|
+
if (message.windowEnd !== undefined) {
|
|
19767
|
+
obj.windowEnd = message.windowEnd.toISOString();
|
|
19768
|
+
}
|
|
19769
|
+
return obj;
|
|
19770
|
+
},
|
|
19771
|
+
|
|
19772
|
+
create<I extends Exact<DeepPartial<ModelActivityResponse>, I>>(base?: I): ModelActivityResponse {
|
|
19773
|
+
return ModelActivityResponse.fromPartial(base ?? ({} as any));
|
|
19774
|
+
},
|
|
19775
|
+
fromPartial<I extends Exact<DeepPartial<ModelActivityResponse>, I>>(object: I): ModelActivityResponse {
|
|
19776
|
+
const message = createBaseModelActivityResponse();
|
|
19777
|
+
message.status = (object.status !== undefined && object.status !== null)
|
|
19778
|
+
? ResponseStatus.fromPartial(object.status)
|
|
19779
|
+
: undefined;
|
|
19780
|
+
message.models = object.models?.map((e) => ModelActivity.fromPartial(e)) || [];
|
|
19781
|
+
message.windowStart = object.windowStart ?? undefined;
|
|
19782
|
+
message.windowEnd = object.windowEnd ?? undefined;
|
|
19783
|
+
return message;
|
|
19784
|
+
},
|
|
19785
|
+
};
|
|
19786
|
+
|
|
19787
|
+
function createBaseModelActivity(): ModelActivity {
|
|
19788
|
+
return {
|
|
19789
|
+
key: "",
|
|
19790
|
+
modelCalls: 0,
|
|
19791
|
+
failedCalls: 0,
|
|
19792
|
+
inputTokens: 0,
|
|
19793
|
+
outputTokens: 0,
|
|
19794
|
+
cacheReadTokens: 0,
|
|
19795
|
+
cacheWriteTokens: 0,
|
|
19796
|
+
costUsd: 0,
|
|
19797
|
+
subscriptionCostUsd: 0,
|
|
19798
|
+
sessions: 0,
|
|
19799
|
+
toolCalls: 0,
|
|
19800
|
+
compactions: 0,
|
|
19801
|
+
subagentRuns: 0,
|
|
19802
|
+
ttftMsSum: 0,
|
|
19803
|
+
ttftCalls: 0,
|
|
19804
|
+
providers: [],
|
|
19805
|
+
principals: [],
|
|
19806
|
+
settledCalls: undefined,
|
|
19807
|
+
};
|
|
19808
|
+
}
|
|
19809
|
+
|
|
19810
|
+
export const ModelActivity: MessageFns<ModelActivity> = {
|
|
19811
|
+
encode(message: ModelActivity, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
|
|
19812
|
+
if (message.key !== "") {
|
|
19813
|
+
writer.uint32(10).string(message.key);
|
|
19814
|
+
}
|
|
19815
|
+
if (message.modelCalls !== 0) {
|
|
19816
|
+
writer.uint32(16).uint64(message.modelCalls);
|
|
19817
|
+
}
|
|
19818
|
+
if (message.failedCalls !== 0) {
|
|
19819
|
+
writer.uint32(24).uint64(message.failedCalls);
|
|
19820
|
+
}
|
|
19821
|
+
if (message.inputTokens !== 0) {
|
|
19822
|
+
writer.uint32(32).uint64(message.inputTokens);
|
|
19823
|
+
}
|
|
19824
|
+
if (message.outputTokens !== 0) {
|
|
19825
|
+
writer.uint32(40).uint64(message.outputTokens);
|
|
19826
|
+
}
|
|
19827
|
+
if (message.cacheReadTokens !== 0) {
|
|
19828
|
+
writer.uint32(48).uint64(message.cacheReadTokens);
|
|
19829
|
+
}
|
|
19830
|
+
if (message.cacheWriteTokens !== 0) {
|
|
19831
|
+
writer.uint32(56).uint64(message.cacheWriteTokens);
|
|
19832
|
+
}
|
|
19833
|
+
if (message.costUsd !== 0) {
|
|
19834
|
+
writer.uint32(65).double(message.costUsd);
|
|
19835
|
+
}
|
|
19836
|
+
if (message.subscriptionCostUsd !== 0) {
|
|
19837
|
+
writer.uint32(73).double(message.subscriptionCostUsd);
|
|
19838
|
+
}
|
|
19839
|
+
if (message.sessions !== 0) {
|
|
19840
|
+
writer.uint32(80).uint64(message.sessions);
|
|
19841
|
+
}
|
|
19842
|
+
if (message.toolCalls !== 0) {
|
|
19843
|
+
writer.uint32(88).uint64(message.toolCalls);
|
|
19844
|
+
}
|
|
19845
|
+
if (message.compactions !== 0) {
|
|
19846
|
+
writer.uint32(96).uint64(message.compactions);
|
|
19847
|
+
}
|
|
19848
|
+
if (message.subagentRuns !== 0) {
|
|
19849
|
+
writer.uint32(104).uint64(message.subagentRuns);
|
|
19850
|
+
}
|
|
19851
|
+
if (message.ttftMsSum !== 0) {
|
|
19852
|
+
writer.uint32(112).uint64(message.ttftMsSum);
|
|
19853
|
+
}
|
|
19854
|
+
if (message.ttftCalls !== 0) {
|
|
19855
|
+
writer.uint32(120).uint64(message.ttftCalls);
|
|
19856
|
+
}
|
|
19857
|
+
for (const v of message.providers) {
|
|
19858
|
+
writer.uint32(130).string(v!);
|
|
19859
|
+
}
|
|
19860
|
+
for (const v of message.principals) {
|
|
19861
|
+
ModelActivityPrincipal.encode(v!, writer.uint32(138).fork()).join();
|
|
19862
|
+
}
|
|
19863
|
+
if (message.settledCalls !== undefined) {
|
|
19864
|
+
writer.uint32(144).uint64(message.settledCalls);
|
|
19865
|
+
}
|
|
19866
|
+
return writer;
|
|
19867
|
+
},
|
|
19868
|
+
|
|
19869
|
+
decode(input: BinaryReader | Uint8Array, length?: number): ModelActivity {
|
|
19870
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
19871
|
+
const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
|
|
19872
|
+
if (previousRecursionDepth >= 100) {
|
|
19873
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
19874
|
+
}
|
|
19875
|
+
(reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
19876
|
+
try {
|
|
19877
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
19878
|
+
const message = createBaseModelActivity();
|
|
19879
|
+
while (reader.pos < end) {
|
|
19880
|
+
const tag = reader.uint32();
|
|
19881
|
+
switch (tag >>> 3) {
|
|
19882
|
+
case 1: {
|
|
19883
|
+
if (tag !== 10) {
|
|
19884
|
+
break;
|
|
19885
|
+
}
|
|
19886
|
+
|
|
19887
|
+
message.key = reader.string();
|
|
19888
|
+
continue;
|
|
19889
|
+
}
|
|
19890
|
+
case 2: {
|
|
19891
|
+
if (tag !== 16) {
|
|
19892
|
+
break;
|
|
19893
|
+
}
|
|
19894
|
+
|
|
19895
|
+
message.modelCalls = longToNumber(reader.uint64());
|
|
19896
|
+
continue;
|
|
19897
|
+
}
|
|
19898
|
+
case 3: {
|
|
19899
|
+
if (tag !== 24) {
|
|
19900
|
+
break;
|
|
19901
|
+
}
|
|
18465
19902
|
|
|
18466
19903
|
message.failedCalls = longToNumber(reader.uint64());
|
|
18467
19904
|
continue;
|
|
@@ -26804,6 +28241,12 @@ export interface AIGatewayService {
|
|
|
26804
28241
|
* costliest first. Mirrors telemetry.api.v1.
|
|
26805
28242
|
*/
|
|
26806
28243
|
ListModelActivity(request: ModelActivityRequest, metadata?: Metadata): Promise<ModelActivityResponse>;
|
|
28244
|
+
/**
|
|
28245
|
+
* How much each model thought per call over a time range, one row per (model, effort) after groups fold stored
|
|
28246
|
+
* spellings: counted calls, exact medians and p90 per call and per turn, and each overlapped ISO week's median;
|
|
28247
|
+
* with coverage and what served the calls. Counts only. Mirrors ai.api.v1.
|
|
28248
|
+
*/
|
|
28249
|
+
ListModelReasoning(request: ListModelReasoningRequest, metadata?: Metadata): Promise<ListModelReasoningResponse>;
|
|
26807
28250
|
/**
|
|
26808
28251
|
* One session's model calls and git activity on one epoch-aligned time grid: per bucket, each model's
|
|
26809
28252
|
* calls, tokens and cost, and each git action's count. Mirrors telemetry.api.v1.
|
|
@@ -26872,6 +28315,7 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
|
|
|
26872
28315
|
this.ListModelPriceHistory = this.ListModelPriceHistory.bind(this);
|
|
26873
28316
|
this.ListResourceRankings = this.ListResourceRankings.bind(this);
|
|
26874
28317
|
this.ListModelActivity = this.ListModelActivity.bind(this);
|
|
28318
|
+
this.ListModelReasoning = this.ListModelReasoning.bind(this);
|
|
26875
28319
|
this.GetSessionUsageTrend = this.GetSessionUsageTrend.bind(this);
|
|
26876
28320
|
this.GetSessionAnalysis = this.GetSessionAnalysis.bind(this);
|
|
26877
28321
|
this.GetSessionScoreTrend = this.GetSessionScoreTrend.bind(this);
|
|
@@ -27032,6 +28476,12 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
|
|
|
27032
28476
|
return promise.then((data) => ModelActivityResponse.decode(new BinaryReader(data)));
|
|
27033
28477
|
}
|
|
27034
28478
|
|
|
28479
|
+
ListModelReasoning(request: ListModelReasoningRequest, metadata?: Metadata): Promise<ListModelReasoningResponse> {
|
|
28480
|
+
const data = ListModelReasoningRequest.encode(request).finish();
|
|
28481
|
+
const promise = this.rpc.request(this.service, "ListModelReasoning", data, metadata);
|
|
28482
|
+
return promise.then((data) => ListModelReasoningResponse.decode(new BinaryReader(data)));
|
|
28483
|
+
}
|
|
28484
|
+
|
|
27035
28485
|
GetSessionUsageTrend(request: SessionUsageTrendRequest, metadata?: Metadata): Promise<SessionUsageTrendResponse> {
|
|
27036
28486
|
const data = SessionUsageTrendRequest.encode(request).finish();
|
|
27037
28487
|
const promise = this.rpc.request(this.service, "GetSessionUsageTrend", data, metadata);
|