@miradorlabs/web-grpc 3.6.0 → 3.7.0

package/proto/gateway/web/v1/ai_gateway.ts

@@ -1636,6 +1636,57 @@ export interface ModelActivityPrincipal {
   costUsd: number;
 }
 
+export interface SessionUsageTrendRequest {
+  organizationId: string;
+  projectId: string;
+  sourceSystem: string;
+  /** The session's routing-key partitions, 1 to 100, read as one session. */
+  sessionIds: string[];
+  /**
+   * Bucket width in seconds, > 0; buckets start at multiples of it since the Unix epoch (UTC). Widened to
+   * the next step of 1, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200, 10800, 21600, 43200 s or a
+   * whole number of days when the session would span more than 2000 buckets.
+   */
+  bucketSeconds: number;
+}
+
+export interface SessionUsageTrendResponse {
+  status:
+    | ResponseStatus
+    | undefined;
+  /** the width the buckets use */
+  bucketSeconds: number;
+  /** per (bucket, model), by bucket_start then model */
+  buckets: SessionUsageBucket[];
+  /** per (bucket, action), by bucket_start then action */
+  gitBuckets: SessionGitBucket[];
+}
+
+/**
+ * SessionUsageBucket: model is the stored name, '' when unreported; input_tokens is cache-inclusive, the
+ * cache fields are subsets.
+ */
+export interface SessionUsageBucket {
+  bucketStart: Date | undefined;
+  model: string;
+  modelCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  costUsd: number;
+}
+
+/**
+ * SessionGitBucket: the stored action (commit, push, pr_create, pr_merge, …), counted as the session rollup
+ * counts it (known failures left out).
+ */
+export interface SessionGitBucket {
+  bucketStart: Date | undefined;
+  action: string;
+  count: number;
+}
+
 /** AISessionRef is a session's identity: two sources can issue the same session_id. */
 export interface AISessionRef {
   sourceSystem: string;
@@ -13696,22 +13747,31 @@ export const ModelActivityPrincipal: MessageFns<ModelActivityPrincipal> = {
   },
 };
 
-function createBaseAISessionRef(): AISessionRef {
-  return { sourceSystem: "", sessionId: "" };
+function createBaseSessionUsageTrendRequest(): SessionUsageTrendRequest {
+  return { organizationId: "", projectId: "", sourceSystem: "", sessionIds: [], bucketSeconds: 0 };
 }
 
-export const AISessionRef: MessageFns<AISessionRef> = {
-  encode(message: AISessionRef, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const SessionUsageTrendRequest: MessageFns<SessionUsageTrendRequest> = {
+  encode(message: SessionUsageTrendRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
     if (message.sourceSystem !== "") {
-      writer.uint32(10).string(message.sourceSystem);
+      writer.uint32(26).string(message.sourceSystem);
     }
-    if (message.sessionId !== "") {
-      writer.uint32(18).string(message.sessionId);
+    for (const v of message.sessionIds) {
+      writer.uint32(34).string(v!);
+    }
+    if (message.bucketSeconds !== 0) {
+      writer.uint32(40).uint32(message.bucketSeconds);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): AISessionRef {
+  decode(input: BinaryReader | Uint8Array, length?: number): SessionUsageTrendRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -13720,7 +13780,7 @@ export const AISessionRef: MessageFns<AISessionRef> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseAISessionRef();
+      const message = createBaseSessionUsageTrendRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -13729,7 +13789,7 @@ export const AISessionRef: MessageFns<AISessionRef> = {
               break;
             }
 
-            message.sourceSystem = reader.string();
+            message.organizationId = reader.string();
             continue;
           }
           case 2: {
@@ -13737,7 +13797,31 @@ export const AISessionRef: MessageFns<AISessionRef> = {
               break;
             }
 
-            message.sessionId = reader.string();
+            message.projectId = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.sourceSystem = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.sessionIds.push(reader.string());
+            continue;
+          }
+          case 5: {
+            if (tag !== 40) {
+              break;
+            }
+
+            message.bucketSeconds = reader.uint32();
             continue;
           }
         }
@@ -13752,94 +13836,92 @@ export const AISessionRef: MessageFns<AISessionRef> = {
     }
   },
 
-  fromJSON(object: any): AISessionRef {
+  fromJSON(object: any): SessionUsageTrendRequest {
     return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
       sourceSystem: isSet(object.sourceSystem)
         ? globalThis.String(object.sourceSystem)
         : isSet(object.source_system)
         ? globalThis.String(object.source_system)
         : "",
-      sessionId: isSet(object.sessionId)
-        ? globalThis.String(object.sessionId)
-        : isSet(object.session_id)
-        ? globalThis.String(object.session_id)
-        : "",
+      sessionIds: globalThis.Array.isArray(object?.sessionIds)
+        ? object.sessionIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.session_ids)
+        ? object.session_ids.map((e: any) => globalThis.String(e))
+        : [],
+      bucketSeconds: isSet(object.bucketSeconds)
+        ? globalThis.Number(object.bucketSeconds)
+        : isSet(object.bucket_seconds)
+        ? globalThis.Number(object.bucket_seconds)
+        : 0,
     };
   },
 
-  toJSON(message: AISessionRef): unknown {
+  toJSON(message: SessionUsageTrendRequest): unknown {
     const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
     if (message.sourceSystem !== "") {
       obj.sourceSystem = message.sourceSystem;
     }
-    if (message.sessionId !== "") {
-      obj.sessionId = message.sessionId;
+    if (message.sessionIds?.length) {
+      obj.sessionIds = message.sessionIds;
+    }
+    if (message.bucketSeconds !== 0) {
+      obj.bucketSeconds = Math.round(message.bucketSeconds);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<AISessionRef>, I>>(base?: I): AISessionRef {
-    return AISessionRef.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<SessionUsageTrendRequest>, I>>(base?: I): SessionUsageTrendRequest {
+    return SessionUsageTrendRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<AISessionRef>, I>>(object: I): AISessionRef {
-    const message = createBaseAISessionRef();
+  fromPartial<I extends Exact<DeepPartial<SessionUsageTrendRequest>, I>>(object: I): SessionUsageTrendRequest {
+    const message = createBaseSessionUsageTrendRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
     message.sourceSystem = object.sourceSystem ?? "";
-    message.sessionId = object.sessionId ?? "";
+    message.sessionIds = object.sessionIds?.map((e) => e) || [];
+    message.bucketSeconds = object.bucketSeconds ?? 0;
     return message;
   },
 };
 
-function createBaseAIFileFilter(): AIFileFilter {
-  return {
-    repositoryKey: [],
-    ref: [],
-    state: [],
-    tier: [],
-    session: [],
-    minAge: undefined,
-    activeAfter: undefined,
-    activeBefore: undefined,
-    abandonedHorizon: undefined,
-  };
+function createBaseSessionUsageTrendResponse(): SessionUsageTrendResponse {
+  return { status: undefined, bucketSeconds: 0, buckets: [], gitBuckets: [] };
 }
 
-export const AIFileFilter: MessageFns<AIFileFilter> = {
-  encode(message: AIFileFilter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.repositoryKey) {
-      writer.uint32(10).string(v!);
-    }
-    for (const v of message.ref) {
-      writer.uint32(18).string(v!);
-    }
-    writer.uint32(26).fork();
-    for (const v of message.state) {
-      writer.int32(v);
-    }
-    writer.join();
-    writer.uint32(34).fork();
-    for (const v of message.tier) {
-      writer.int32(v);
-    }
-    writer.join();
-    for (const v of message.session) {
-      AISessionRef.encode(v!, writer.uint32(42).fork()).join();
-    }
-    if (message.minAge !== undefined) {
-      Duration.encode(message.minAge, writer.uint32(50).fork()).join();
+export const SessionUsageTrendResponse: MessageFns<SessionUsageTrendResponse> = {
+  encode(message: SessionUsageTrendResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    if (message.activeAfter !== undefined) {
-      Timestamp.encode(toTimestamp(message.activeAfter), writer.uint32(58).fork()).join();
+    if (message.bucketSeconds !== 0) {
+      writer.uint32(16).uint32(message.bucketSeconds);
     }
-    if (message.activeBefore !== undefined) {
-      Timestamp.encode(toTimestamp(message.activeBefore), writer.uint32(66).fork()).join();
+    for (const v of message.buckets) {
+      SessionUsageBucket.encode(v!, writer.uint32(26).fork()).join();
     }
-    if (message.abandonedHorizon !== undefined) {
-      Duration.encode(message.abandonedHorizon, writer.uint32(74).fork()).join();
+    for (const v of message.gitBuckets) {
+      SessionGitBucket.encode(v!, writer.uint32(34).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): AIFileFilter {
+  decode(input: BinaryReader | Uint8Array, length?: number): SessionUsageTrendResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -13848,7 +13930,7 @@ export const AIFileFilter: MessageFns<AIFileFilter> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseAIFileFilter();
+      const message = createBaseSessionUsageTrendResponse();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -13857,91 +13939,31 @@ export const AIFileFilter: MessageFns<AIFileFilter> = {
               break;
             }
 
-            message.repositoryKey.push(reader.string());
+            message.status = ResponseStatus.decode(reader, reader.uint32());
             continue;
           }
           case 2: {
-            if (tag !== 18) {
+            if (tag !== 16) {
               break;
             }
 
-            message.ref.push(reader.string());
+            message.bucketSeconds = reader.uint32();
             continue;
           }
           case 3: {
-            if (tag === 24) {
-              message.state.push(reader.int32() as any);
-
-              continue;
-            }
-
-            if (tag === 26) {
-              const end2 = reader.uint32() + reader.pos;
-              while (reader.pos < end2) {
-                message.state.push(reader.int32() as any);
-              }
-
-              continue;
-            }
-
-            break;
-          }
-          case 4: {
-            if (tag === 32) {
-              message.tier.push(reader.int32() as any);
-
-              continue;
-            }
-
-            if (tag === 34) {
-              const end2 = reader.uint32() + reader.pos;
-              while (reader.pos < end2) {
-                message.tier.push(reader.int32() as any);
-              }
-
-              continue;
-            }
-
-            break;
-          }
-          case 5: {
-            if (tag !== 42) {
-              break;
-            }
-
-            message.session.push(AISessionRef.decode(reader, reader.uint32()));
-            continue;
-          }
-          case 6: {
-            if (tag !== 50) {
-              break;
-            }
-
-            message.minAge = Duration.decode(reader, reader.uint32());
-            continue;
-          }
-          case 7: {
-            if (tag !== 58) {
-              break;
-            }
-
-            message.activeAfter = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-            continue;
-          }
-          case 8: {
-            if (tag !== 66) {
+            if (tag !== 26) {
               break;
             }
 
-            message.activeBefore = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            message.buckets.push(SessionUsageBucket.decode(reader, reader.uint32()));
             continue;
           }
-          case 9: {
-            if (tag !== 74) {
+          case 4: {
+            if (tag !== 34) {
               break;
             }
 
-            message.abandonedHorizon = Duration.decode(reader, reader.uint32());
+            message.gitBuckets.push(SessionGitBucket.decode(reader, reader.uint32()));
             continue;
           }
         }
@@ -13956,36 +13978,670 @@ export const AIFileFilter: MessageFns<AIFileFilter> = {
     }
   },
 
-  fromJSON(object: any): AIFileFilter {
+  fromJSON(object: any): SessionUsageTrendResponse {
     return {
-      repositoryKey: globalThis.Array.isArray(object?.repositoryKey)
-        ? object.repositoryKey.map((e: any) => globalThis.String(e))
-        : globalThis.Array.isArray(object?.repository_key)
-        ? object.repository_key.map((e: any) => globalThis.String(e))
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      bucketSeconds: isSet(object.bucketSeconds)
+        ? globalThis.Number(object.bucketSeconds)
+        : isSet(object.bucket_seconds)
+        ? globalThis.Number(object.bucket_seconds)
+        : 0,
+      buckets: globalThis.Array.isArray(object?.buckets)
+        ? object.buckets.map((e: any) => SessionUsageBucket.fromJSON(e))
         : [],
-      ref: globalThis.Array.isArray(object?.ref) ? object.ref.map((e: any) => globalThis.String(e)) : [],
-      state: globalThis.Array.isArray(object?.state) ? object.state.map((e: any) => aIFileLifecycleFromJSON(e)) : [],
-      tier: globalThis.Array.isArray(object?.tier) ? object.tier.map((e: any) => aIFileTierFromJSON(e)) : [],
-      session: globalThis.Array.isArray(object?.session)
-        ? object.session.map((e: any) => AISessionRef.fromJSON(e))
+      gitBuckets: globalThis.Array.isArray(object?.gitBuckets)
+        ? object.gitBuckets.map((e: any) => SessionGitBucket.fromJSON(e))
+        : globalThis.Array.isArray(object?.git_buckets)
+        ? object.git_buckets.map((e: any) => SessionGitBucket.fromJSON(e))
         : [],
-      minAge: isSet(object.minAge)
-        ? Duration.fromJSON(object.minAge)
-        : isSet(object.min_age)
-        ? Duration.fromJSON(object.min_age)
-        : undefined,
-      activeAfter: isSet(object.activeAfter)
-        ? fromJsonTimestamp(object.activeAfter)
-        : isSet(object.active_after)
-        ? fromJsonTimestamp(object.active_after)
-        : undefined,
-      activeBefore: isSet(object.activeBefore)
-        ? fromJsonTimestamp(object.activeBefore)
-        : isSet(object.active_before)
-        ? fromJsonTimestamp(object.active_before)
-        : undefined,
-      abandonedHorizon: isSet(object.abandonedHorizon)
-        ? Duration.fromJSON(object.abandonedHorizon)
+    };
+  },
+
+  toJSON(message: SessionUsageTrendResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.bucketSeconds !== 0) {
+      obj.bucketSeconds = Math.round(message.bucketSeconds);
+    }
+    if (message.buckets?.length) {
+      obj.buckets = message.buckets.map((e) => SessionUsageBucket.toJSON(e));
+    }
+    if (message.gitBuckets?.length) {
+      obj.gitBuckets = message.gitBuckets.map((e) => SessionGitBucket.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SessionUsageTrendResponse>, I>>(base?: I): SessionUsageTrendResponse {
+    return SessionUsageTrendResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SessionUsageTrendResponse>, I>>(object: I): SessionUsageTrendResponse {
+    const message = createBaseSessionUsageTrendResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.bucketSeconds = object.bucketSeconds ?? 0;
+    message.buckets = object.buckets?.map((e) => SessionUsageBucket.fromPartial(e)) || [];
+    message.gitBuckets = object.gitBuckets?.map((e) => SessionGitBucket.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSessionUsageBucket(): SessionUsageBucket {
+  return {
+    bucketStart: undefined,
+    model: "",
+    modelCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUsd: 0,
+  };
+}
+
+export const SessionUsageBucket: MessageFns<SessionUsageBucket> = {
+  encode(message: SessionUsageBucket, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.bucketStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.bucketStart), writer.uint32(10).fork()).join();
+    }
+    if (message.model !== "") {
+      writer.uint32(18).string(message.model);
+    }
+    if (message.modelCalls !== 0) {
+      writer.uint32(24).uint64(message.modelCalls);
+    }
+    if (message.inputTokens !== 0) {
+      writer.uint32(32).uint64(message.inputTokens);
+    }
+    if (message.outputTokens !== 0) {
+      writer.uint32(40).uint64(message.outputTokens);
+    }
+    if (message.cacheReadTokens !== 0) {
+      writer.uint32(48).uint64(message.cacheReadTokens);
+    }
+    if (message.cacheWriteTokens !== 0) {
+      writer.uint32(56).uint64(message.cacheWriteTokens);
+    }
+    if (message.costUsd !== 0) {
+      writer.uint32(65).double(message.costUsd);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SessionUsageBucket {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSessionUsageBucket();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.bucketStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.model = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.modelCalls = longToNumber(reader.uint64());
+            continue;
+          }
+          case 4: {
+            if (tag !== 32) {
+              break;
+            }
+
+            message.inputTokens = longToNumber(reader.uint64());
+            continue;
+          }
+          case 5: {
+            if (tag !== 40) {
+              break;
+            }
+
+            message.outputTokens = longToNumber(reader.uint64());
+            continue;
+          }
+          case 6: {
+            if (tag !== 48) {
+              break;
+            }
+
+            message.cacheReadTokens = longToNumber(reader.uint64());
+            continue;
+          }
+          case 7: {
+            if (tag !== 56) {
+              break;
+            }
+
+            message.cacheWriteTokens = longToNumber(reader.uint64());
+            continue;
+          }
+          case 8: {
+            if (tag !== 65) {
+              break;
+            }
+
+            message.costUsd = reader.double();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SessionUsageBucket {
+    return {
+      bucketStart: isSet(object.bucketStart)
+        ? fromJsonTimestamp(object.bucketStart)
+        : isSet(object.bucket_start)
+        ? fromJsonTimestamp(object.bucket_start)
+        : undefined,
+      model: isSet(object.model) ? globalThis.String(object.model) : "",
+      modelCalls: isSet(object.modelCalls)
+        ? globalThis.Number(object.modelCalls)
+        : isSet(object.model_calls)
+        ? globalThis.Number(object.model_calls)
+        : 0,
+      inputTokens: isSet(object.inputTokens)
+        ? globalThis.Number(object.inputTokens)
+        : isSet(object.input_tokens)
+        ? globalThis.Number(object.input_tokens)
+        : 0,
+      outputTokens: isSet(object.outputTokens)
+        ? globalThis.Number(object.outputTokens)
+        : isSet(object.output_tokens)
+        ? globalThis.Number(object.output_tokens)
+        : 0,
+      cacheReadTokens: isSet(object.cacheReadTokens)
+        ? globalThis.Number(object.cacheReadTokens)
+        : isSet(object.cache_read_tokens)
+        ? globalThis.Number(object.cache_read_tokens)
+        : 0,
+      cacheWriteTokens: isSet(object.cacheWriteTokens)
+        ? globalThis.Number(object.cacheWriteTokens)
+        : isSet(object.cache_write_tokens)
+        ? globalThis.Number(object.cache_write_tokens)
+        : 0,
+      costUsd: isSet(object.costUsd)
+        ? globalThis.Number(object.costUsd)
+        : isSet(object.cost_usd)
+        ? globalThis.Number(object.cost_usd)
+        : 0,
+    };
+  },
+
+  toJSON(message: SessionUsageBucket): unknown {
+    const obj: any = {};
+    if (message.bucketStart !== undefined) {
+      obj.bucketStart = message.bucketStart.toISOString();
+    }
+    if (message.model !== "") {
+      obj.model = message.model;
+    }
+    if (message.modelCalls !== 0) {
+      obj.modelCalls = Math.round(message.modelCalls);
+    }
+    if (message.inputTokens !== 0) {
+      obj.inputTokens = Math.round(message.inputTokens);
+    }
+    if (message.outputTokens !== 0) {
+      obj.outputTokens = Math.round(message.outputTokens);
+    }
+    if (message.cacheReadTokens !== 0) {
+      obj.cacheReadTokens = Math.round(message.cacheReadTokens);
+    }
+    if (message.cacheWriteTokens !== 0) {
+      obj.cacheWriteTokens = Math.round(message.cacheWriteTokens);
+    }
+    if (message.costUsd !== 0) {
+      obj.costUsd = message.costUsd;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SessionUsageBucket>, I>>(base?: I): SessionUsageBucket {
+    return SessionUsageBucket.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SessionUsageBucket>, I>>(object: I): SessionUsageBucket {
+    const message = createBaseSessionUsageBucket();
+    message.bucketStart = object.bucketStart ?? undefined;
+    message.model = object.model ?? "";
+    message.modelCalls = object.modelCalls ?? 0;
+    message.inputTokens = object.inputTokens ?? 0;
+    message.outputTokens = object.outputTokens ?? 0;
+    message.cacheReadTokens = object.cacheReadTokens ?? 0;
+    message.cacheWriteTokens = object.cacheWriteTokens ?? 0;
+    message.costUsd = object.costUsd ?? 0;
+    return message;
+  },
+};
+
+function createBaseSessionGitBucket(): SessionGitBucket {
+  return { bucketStart: undefined, action: "", count: 0 };
+}
+
+export const SessionGitBucket: MessageFns<SessionGitBucket> = {
+  encode(message: SessionGitBucket, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.bucketStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.bucketStart), writer.uint32(10).fork()).join();
+    }
+    if (message.action !== "") {
+      writer.uint32(18).string(message.action);
+    }
+    if (message.count !== 0) {
+      writer.uint32(24).uint64(message.count);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SessionGitBucket {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSessionGitBucket();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.bucketStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.action = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.count = longToNumber(reader.uint64());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SessionGitBucket {
+    return {
+      bucketStart: isSet(object.bucketStart)
+        ? fromJsonTimestamp(object.bucketStart)
+        : isSet(object.bucket_start)
+        ? fromJsonTimestamp(object.bucket_start)
+        : undefined,
+      action: isSet(object.action) ? globalThis.String(object.action) : "",
+      count: isSet(object.count) ? globalThis.Number(object.count) : 0,
+    };
+  },
+
+  toJSON(message: SessionGitBucket): unknown {
+    const obj: any = {};
+    if (message.bucketStart !== undefined) {
+      obj.bucketStart = message.bucketStart.toISOString();
+    }
+    if (message.action !== "") {
+      obj.action = message.action;
+    }
+    if (message.count !== 0) {
+      obj.count = Math.round(message.count);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SessionGitBucket>, I>>(base?: I): SessionGitBucket {
+    return SessionGitBucket.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SessionGitBucket>, I>>(object: I): SessionGitBucket {
+    const message = createBaseSessionGitBucket();
+    message.bucketStart = object.bucketStart ?? undefined;
+    message.action = object.action ?? "";
+    message.count = object.count ?? 0;
+    return message;
+  },
+};
+
+function createBaseAISessionRef(): AISessionRef {
+  return { sourceSystem: "", sessionId: "" };
+}
+
+export const AISessionRef: MessageFns<AISessionRef> = {
+  encode(message: AISessionRef, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sourceSystem !== "") {
+      writer.uint32(10).string(message.sourceSystem);
+    }
+    if (message.sessionId !== "") {
+      writer.uint32(18).string(message.sessionId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AISessionRef {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseAISessionRef();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.sourceSystem = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.sessionId = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AISessionRef {
+    return {
+      sourceSystem: isSet(object.sourceSystem)
+        ? globalThis.String(object.sourceSystem)
+        : isSet(object.source_system)
+        ? globalThis.String(object.source_system)
+        : "",
+      sessionId: isSet(object.sessionId)
+        ? globalThis.String(object.sessionId)
+        : isSet(object.session_id)
+        ? globalThis.String(object.session_id)
+        : "",
+    };
+  },
+
+  toJSON(message: AISessionRef): unknown {
+    const obj: any = {};
+    if (message.sourceSystem !== "") {
+      obj.sourceSystem = message.sourceSystem;
+    }
+    if (message.sessionId !== "") {
+      obj.sessionId = message.sessionId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<AISessionRef>, I>>(base?: I): AISessionRef {
+    return AISessionRef.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<AISessionRef>, I>>(object: I): AISessionRef {
+    const message = createBaseAISessionRef();
+    message.sourceSystem = object.sourceSystem ?? "";
+    message.sessionId = object.sessionId ?? "";
+    return message;
+  },
+};
+
+function createBaseAIFileFilter(): AIFileFilter {
+  return {
+    repositoryKey: [],
+    ref: [],
+    state: [],
+    tier: [],
+    session: [],
+    minAge: undefined,
+    activeAfter: undefined,
+    activeBefore: undefined,
+    abandonedHorizon: undefined,
+  };
+}
+
+export const AIFileFilter: MessageFns<AIFileFilter> = {
+  encode(message: AIFileFilter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.repositoryKey) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.ref) {
+      writer.uint32(18).string(v!);
+    }
+    writer.uint32(26).fork();
+    for (const v of message.state) {
+      writer.int32(v);
+    }
+    writer.join();
+    writer.uint32(34).fork();
+    for (const v of message.tier) {
+      writer.int32(v);
+    }
+    writer.join();
+    for (const v of message.session) {
+      AISessionRef.encode(v!, writer.uint32(42).fork()).join();
+    }
+    if (message.minAge !== undefined) {
+      Duration.encode(message.minAge, writer.uint32(50).fork()).join();
+    }
+    if (message.activeAfter !== undefined) {
+      Timestamp.encode(toTimestamp(message.activeAfter), writer.uint32(58).fork()).join();
+    }
+    if (message.activeBefore !== undefined) {
+      Timestamp.encode(toTimestamp(message.activeBefore), writer.uint32(66).fork()).join();
+    }
+    if (message.abandonedHorizon !== undefined) {
+      Duration.encode(message.abandonedHorizon, writer.uint32(74).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AIFileFilter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseAIFileFilter();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.repositoryKey.push(reader.string());
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.ref.push(reader.string());
+            continue;
+          }
+          case 3: {
+            if (tag === 24) {
+              message.state.push(reader.int32() as any);
+
+              continue;
+            }
+
+            if (tag === 26) {
+              const end2 = reader.uint32() + reader.pos;
+              while (reader.pos < end2) {
+                message.state.push(reader.int32() as any);
+              }
+
+              continue;
+            }
+
+            break;
+          }
+          case 4: {
+            if (tag === 32) {
+              message.tier.push(reader.int32() as any);
+
+              continue;
+            }
+
+            if (tag === 34) {
+              const end2 = reader.uint32() + reader.pos;
+              while (reader.pos < end2) {
+                message.tier.push(reader.int32() as any);
+              }
+
+              continue;
+            }
+
+            break;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.session.push(AISessionRef.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 6: {
+            if (tag !== 50) {
+              break;
+            }
+
+            message.minAge = Duration.decode(reader, reader.uint32());
+            continue;
+          }
+          case 7: {
+            if (tag !== 58) {
+              break;
+            }
+
+            message.activeAfter = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.activeBefore = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.abandonedHorizon = Duration.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AIFileFilter {
+    return {
+      repositoryKey: globalThis.Array.isArray(object?.repositoryKey)
+        ? object.repositoryKey.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.repository_key)
+        ? object.repository_key.map((e: any) => globalThis.String(e))
+        : [],
+      ref: globalThis.Array.isArray(object?.ref) ? object.ref.map((e: any) => globalThis.String(e)) : [],
+      state: globalThis.Array.isArray(object?.state) ? object.state.map((e: any) => aIFileLifecycleFromJSON(e)) : [],
+      tier: globalThis.Array.isArray(object?.tier) ? object.tier.map((e: any) => aIFileTierFromJSON(e)) : [],
+      session: globalThis.Array.isArray(object?.session)
+        ? object.session.map((e: any) => AISessionRef.fromJSON(e))
+        : [],
+      minAge: isSet(object.minAge)
+        ? Duration.fromJSON(object.minAge)
+        : isSet(object.min_age)
+        ? Duration.fromJSON(object.min_age)
+        : undefined,
+      activeAfter: isSet(object.activeAfter)
+        ? fromJsonTimestamp(object.activeAfter)
+        : isSet(object.active_after)
+        ? fromJsonTimestamp(object.active_after)
+        : undefined,
+      activeBefore: isSet(object.activeBefore)
+        ? fromJsonTimestamp(object.activeBefore)
+        : isSet(object.active_before)
+        ? fromJsonTimestamp(object.active_before)
+        : undefined,
+      abandonedHorizon: isSet(object.abandonedHorizon)
+        ? Duration.fromJSON(object.abandonedHorizon)
         : isSet(object.abandoned_horizon)
         ? Duration.fromJSON(object.abandoned_horizon)
         : undefined,
@@ -17741,6 +18397,11 @@ export interface AIGatewayService {
    * costliest first. Mirrors telemetry.api.v1.
    */
   ListModelActivity(request: ModelActivityRequest, metadata?: Metadata): Promise<ModelActivityResponse>;
+  /**
+   * One session's model calls and git activity on one epoch-aligned time grid: per bucket, each model's
+   * calls, tokens and cost, and each git action's count. Mirrors telemetry.api.v1.
+   */
+  GetSessionUsageTrend(request: SessionUsageTrendRequest, metadata?: Metadata): Promise<SessionUsageTrendResponse>;
   /**
    * Per-seat entitlement usage board: every entitlement owner's latest observed funding facility and
    * per-harness usage % windows. Stream-first (first frame = full snapshot), seat-scoped. Mirrors
@@ -17777,6 +18438,7 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     this.ListModelPriceHistory = this.ListModelPriceHistory.bind(this);
     this.ListResourceRankings = this.ListResourceRankings.bind(this);
     this.ListModelActivity = this.ListModelActivity.bind(this);
+    this.GetSessionUsageTrend = this.GetSessionUsageTrend.bind(this);
     this.StreamEntitlements = this.StreamEntitlements.bind(this);
   }
   ListSessions(request: ListSessionsRequest, metadata?: Metadata): Promise<ListSessionsResponse> {
@@ -17914,6 +18576,12 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     return promise.then((data) => ModelActivityResponse.decode(new BinaryReader(data)));
   }
 
+  GetSessionUsageTrend(request: SessionUsageTrendRequest, metadata?: Metadata): Promise<SessionUsageTrendResponse> {
+    const data = SessionUsageTrendRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetSessionUsageTrend", data, metadata);
+    return promise.then((data) => SessionUsageTrendResponse.decode(new BinaryReader(data)));
+  }
+
   StreamEntitlements(request: StreamEntitlementsRequest, metadata?: Metadata): Observable<EntitlementsSnapshot> {
     const data = StreamEntitlementsRequest.encode(request).finish();
     const result = this.rpc.serverStreamingRequest(this.service, "StreamEntitlements", data, metadata);