@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 createBaseModelActivityResponse(): ModelActivityResponse {
18224
- return { status: undefined, models: [], windowStart: undefined, windowEnd: undefined };
18334
+ function createBaseListModelReasoningRequest(): ListModelReasoningRequest {
18335
+ return { organizationId: "", projectId: "", groups: [], effortGroups: [], startTime: undefined, endTime: undefined };
18225
18336
  }
18226
18337
 
18227
- export const ModelActivityResponse: MessageFns<ModelActivityResponse> = {
18228
- encode(message: ModelActivityResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
18229
- if (message.status !== undefined) {
18230
- ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
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
- for (const v of message.models) {
18233
- ModelActivity.encode(v!, writer.uint32(18).fork()).join();
18343
+ if (message.projectId !== "") {
18344
+ writer.uint32(18).string(message.projectId);
18234
18345
  }
18235
- if (message.windowStart !== undefined) {
18236
- Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(26).fork()).join();
18346
+ for (const v of message.groups) {
18347
+ ModelActivityGroup.encode(v!, writer.uint32(26).fork()).join();
18237
18348
  }
18238
- if (message.windowEnd !== undefined) {
18239
- Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(34).fork()).join();
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): ModelActivityResponse {
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 = createBaseModelActivityResponse();
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.status = ResponseStatus.decode(reader, reader.uint32());
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.models.push(ModelActivity.decode(reader, reader.uint32()));
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.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
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.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
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): ModelActivityResponse {
18434
+ fromJSON(object: any): ListModelReasoningRequest {
18302
18435
  return {
18303
- status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
18304
- models: globalThis.Array.isArray(object?.models) ? object.models.map((e: any) => ModelActivity.fromJSON(e)) : [],
18305
- windowStart: isSet(object.windowStart)
18306
- ? fromJsonTimestamp(object.windowStart)
18307
- : isSet(object.window_start)
18308
- ? fromJsonTimestamp(object.window_start)
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
- windowEnd: isSet(object.windowEnd)
18311
- ? fromJsonTimestamp(object.windowEnd)
18312
- : isSet(object.window_end)
18313
- ? fromJsonTimestamp(object.window_end)
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: ModelActivityResponse): unknown {
18467
+ toJSON(message: ListModelReasoningRequest): unknown {
18319
18468
  const obj: any = {};
18320
- if (message.status !== undefined) {
18321
- obj.status = ResponseStatus.toJSON(message.status);
18469
+ if (message.organizationId !== "") {
18470
+ obj.organizationId = message.organizationId;
18322
18471
  }
18323
- if (message.models?.length) {
18324
- obj.models = message.models.map((e) => ModelActivity.toJSON(e));
18472
+ if (message.projectId !== "") {
18473
+ obj.projectId = message.projectId;
18325
18474
  }
18326
- if (message.windowStart !== undefined) {
18327
- obj.windowStart = message.windowStart.toISOString();
18475
+ if (message.groups?.length) {
18476
+ obj.groups = message.groups.map((e) => ModelActivityGroup.toJSON(e));
18328
18477
  }
18329
- if (message.windowEnd !== undefined) {
18330
- obj.windowEnd = message.windowEnd.toISOString();
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<ModelActivityResponse>, I>>(base?: I): ModelActivityResponse {
18336
- return ModelActivityResponse.fromPartial(base ?? ({} as any));
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<ModelActivityResponse>, I>>(object: I): ModelActivityResponse {
18339
- const message = createBaseModelActivityResponse();
18340
- message.status = (object.status !== undefined && object.status !== null)
18341
- ? ResponseStatus.fromPartial(object.status)
18342
- : undefined;
18343
- message.models = object.models?.map((e) => ModelActivity.fromPartial(e)) || [];
18344
- message.windowStart = object.windowStart ?? undefined;
18345
- message.windowEnd = object.windowEnd ?? undefined;
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 createBaseModelActivity(): ModelActivity {
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 ModelActivity: MessageFns<ModelActivity> = {
18374
- encode(message: ModelActivity, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
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
- if (message.modelCalls !== 0) {
18379
- writer.uint32(16).uint64(message.modelCalls);
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): ModelActivity {
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 = createBaseModelActivity();
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 !== 16) {
18542
+ if (tag !== 18) {
18455
18543
  break;
18456
18544
  }
18457
18545
 
18458
- message.modelCalls = longToNumber(reader.uint64());
18546
+ message.effortNames.push(reader.string());
18459
18547
  continue;
18460
18548
  }
18461
- case 3: {
18462
- if (tag !== 24) {
18463
- break;
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);