@miradorlabs/web-grpc 2.57.0 → 2.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miradorlabs/web-grpc",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "description": "Generated gRPC (grpc-js) client stubs for the Mirador web gateway.",
   "main": "index.js",
   "types": "index.d.ts",

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

@@ -1201,6 +1201,46 @@ export interface DailyActivityMeasures {
   branchesCreated: number;
 }
 
+export interface ActivityRhythmRequest {
+  organizationId: string;
+  projectId: string;
+  /** the range; UNSPECIFIED is rejected, capped at 30 days */
+  timeWindow: AnalyticsTimeWindow;
+  /** IANA zone (e.g. "America/New_York"); empty defaults to "UTC". Echoed on the response. */
+  timeZone: string;
+}
+
+/**
+ * ActivityRhythm mirrors telemetry.api.v1.ActivityRhythm: a sparse weekday/hour heatmap replaced wholesale
+ * each tick (streams carry no ResponseStatus). Only slots with at least one event are present.
+ */
+export interface ActivityRhythm {
+  buckets: ActivityRhythmBucket[];
+  windowStart: Date | undefined;
+  windowEnd: Date | undefined;
+  asOf:
+    | Date
+    | undefined;
+  /** resolved IANA zone */
+  timeZone: string;
+}
+
+export interface ActivityRhythmBucket {
+  /** 1 = Monday .. 7 = Sunday */
+  dayOfWeek: number;
+  /** 0 .. 23 */
+  hourOfDay: number;
+  eventCount: number;
+  modelUsage: TokenActivityMeasures | undefined;
+  usageUnavailableCount: number;
+  costUnavailableCount: number;
+  toolCalls: number;
+  userMessages: number;
+  sessions: number;
+  activeUsers: number;
+  topTool: string;
+}
+
 export interface ProjectOverviewRequest {
   organizationId: string;
   projectId: string;
@@ -9518,6 +9558,573 @@ export const DailyActivityMeasures: MessageFns<DailyActivityMeasures> = {
   },
 };
 
+function createBaseActivityRhythmRequest(): ActivityRhythmRequest {
+  return { organizationId: "", projectId: "", timeWindow: 0, timeZone: "" };
+}
+
+export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
+  encode(message: ActivityRhythmRequest, 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.timeWindow !== 0) {
+      writer.uint32(24).int32(message.timeWindow);
+    }
+    if (message.timeZone !== "") {
+      writer.uint32(34).string(message.timeZone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythmRequest {
+    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 = createBaseActivityRhythmRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.projectId = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.timeWindow = reader.int32() as any;
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.timeZone = 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): ActivityRhythmRequest {
+    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)
+        : "",
+      timeWindow: isSet(object.timeWindow)
+        ? analyticsTimeWindowFromJSON(object.timeWindow)
+        : isSet(object.time_window)
+        ? analyticsTimeWindowFromJSON(object.time_window)
+        : 0,
+      timeZone: isSet(object.timeZone)
+        ? globalThis.String(object.timeZone)
+        : isSet(object.time_zone)
+        ? globalThis.String(object.time_zone)
+        : "",
+    };
+  },
+
+  toJSON(message: ActivityRhythmRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.timeWindow !== 0) {
+      obj.timeWindow = analyticsTimeWindowToJSON(message.timeWindow);
+    }
+    if (message.timeZone !== "") {
+      obj.timeZone = message.timeZone;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(base?: I): ActivityRhythmRequest {
+    return ActivityRhythmRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(object: I): ActivityRhythmRequest {
+    const message = createBaseActivityRhythmRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.timeWindow = object.timeWindow ?? 0;
+    message.timeZone = object.timeZone ?? "";
+    return message;
+  },
+};
+
+function createBaseActivityRhythm(): ActivityRhythm {
+  return { buckets: [], windowStart: undefined, windowEnd: undefined, asOf: undefined, timeZone: "" };
+}
+
+export const ActivityRhythm: MessageFns<ActivityRhythm> = {
+  encode(message: ActivityRhythm, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.buckets) {
+      ActivityRhythmBucket.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.windowStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(18).fork()).join();
+    }
+    if (message.windowEnd !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(26).fork()).join();
+    }
+    if (message.asOf !== undefined) {
+      Timestamp.encode(toTimestamp(message.asOf), writer.uint32(34).fork()).join();
+    }
+    if (message.timeZone !== "") {
+      writer.uint32(42).string(message.timeZone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythm {
+    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 = createBaseActivityRhythm();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.buckets.push(ActivityRhythmBucket.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.asOf = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.timeZone = 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): ActivityRhythm {
+    return {
+      buckets: globalThis.Array.isArray(object?.buckets)
+        ? object.buckets.map((e: any) => ActivityRhythmBucket.fromJSON(e))
+        : [],
+      windowStart: isSet(object.windowStart)
+        ? fromJsonTimestamp(object.windowStart)
+        : isSet(object.window_start)
+        ? fromJsonTimestamp(object.window_start)
+        : undefined,
+      windowEnd: isSet(object.windowEnd)
+        ? fromJsonTimestamp(object.windowEnd)
+        : isSet(object.window_end)
+        ? fromJsonTimestamp(object.window_end)
+        : undefined,
+      asOf: isSet(object.asOf)
+        ? fromJsonTimestamp(object.asOf)
+        : isSet(object.as_of)
+        ? fromJsonTimestamp(object.as_of)
+        : undefined,
+      timeZone: isSet(object.timeZone)
+        ? globalThis.String(object.timeZone)
+        : isSet(object.time_zone)
+        ? globalThis.String(object.time_zone)
+        : "",
+    };
+  },
+
+  toJSON(message: ActivityRhythm): unknown {
+    const obj: any = {};
+    if (message.buckets?.length) {
+      obj.buckets = message.buckets.map((e) => ActivityRhythmBucket.toJSON(e));
+    }
+    if (message.windowStart !== undefined) {
+      obj.windowStart = message.windowStart.toISOString();
+    }
+    if (message.windowEnd !== undefined) {
+      obj.windowEnd = message.windowEnd.toISOString();
+    }
+    if (message.asOf !== undefined) {
+      obj.asOf = message.asOf.toISOString();
+    }
+    if (message.timeZone !== "") {
+      obj.timeZone = message.timeZone;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ActivityRhythm>, I>>(base?: I): ActivityRhythm {
+    return ActivityRhythm.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ActivityRhythm>, I>>(object: I): ActivityRhythm {
+    const message = createBaseActivityRhythm();
+    message.buckets = object.buckets?.map((e) => ActivityRhythmBucket.fromPartial(e)) || [];
+    message.windowStart = object.windowStart ?? undefined;
+    message.windowEnd = object.windowEnd ?? undefined;
+    message.asOf = object.asOf ?? undefined;
+    message.timeZone = object.timeZone ?? "";
+    return message;
+  },
+};
+
+function createBaseActivityRhythmBucket(): ActivityRhythmBucket {
+  return {
+    dayOfWeek: 0,
+    hourOfDay: 0,
+    eventCount: 0,
+    modelUsage: undefined,
+    usageUnavailableCount: 0,
+    costUnavailableCount: 0,
+    toolCalls: 0,
+    userMessages: 0,
+    sessions: 0,
+    activeUsers: 0,
+    topTool: "",
+  };
+}
+
+export const ActivityRhythmBucket: MessageFns<ActivityRhythmBucket> = {
+  encode(message: ActivityRhythmBucket, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.dayOfWeek !== 0) {
+      writer.uint32(8).uint32(message.dayOfWeek);
+    }
+    if (message.hourOfDay !== 0) {
+      writer.uint32(16).uint32(message.hourOfDay);
+    }
+    if (message.eventCount !== 0) {
+      writer.uint32(24).uint64(message.eventCount);
+    }
+    if (message.modelUsage !== undefined) {
+      TokenActivityMeasures.encode(message.modelUsage, writer.uint32(34).fork()).join();
+    }
+    if (message.usageUnavailableCount !== 0) {
+      writer.uint32(40).uint64(message.usageUnavailableCount);
+    }
+    if (message.costUnavailableCount !== 0) {
+      writer.uint32(48).uint64(message.costUnavailableCount);
+    }
+    if (message.toolCalls !== 0) {
+      writer.uint32(56).uint64(message.toolCalls);
+    }
+    if (message.userMessages !== 0) {
+      writer.uint32(64).uint64(message.userMessages);
+    }
+    if (message.sessions !== 0) {
+      writer.uint32(72).uint64(message.sessions);
+    }
+    if (message.activeUsers !== 0) {
+      writer.uint32(80).uint64(message.activeUsers);
+    }
+    if (message.topTool !== "") {
+      writer.uint32(90).string(message.topTool);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythmBucket {
+    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 = createBaseActivityRhythmBucket();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.dayOfWeek = reader.uint32();
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.hourOfDay = reader.uint32();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.eventCount = longToNumber(reader.uint64());
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.modelUsage = TokenActivityMeasures.decode(reader, reader.uint32());
+            continue;
+          }
+          case 5: {
+            if (tag !== 40) {
+              break;
+            }
+
+            message.usageUnavailableCount = longToNumber(reader.uint64());
+            continue;
+          }
+          case 6: {
+            if (tag !== 48) {
+              break;
+            }
+
+            message.costUnavailableCount = longToNumber(reader.uint64());
+            continue;
+          }
+          case 7: {
+            if (tag !== 56) {
+              break;
+            }
+
+            message.toolCalls = longToNumber(reader.uint64());
+            continue;
+          }
+          case 8: {
+            if (tag !== 64) {
+              break;
+            }
+
+            message.userMessages = longToNumber(reader.uint64());
+            continue;
+          }
+          case 9: {
+            if (tag !== 72) {
+              break;
+            }
+
+            message.sessions = longToNumber(reader.uint64());
+            continue;
+          }
+          case 10: {
+            if (tag !== 80) {
+              break;
+            }
+
+            message.activeUsers = longToNumber(reader.uint64());
+            continue;
+          }
+          case 11: {
+            if (tag !== 90) {
+              break;
+            }
+
+            message.topTool = 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): ActivityRhythmBucket {
+    return {
+      dayOfWeek: isSet(object.dayOfWeek)
+        ? globalThis.Number(object.dayOfWeek)
+        : isSet(object.day_of_week)
+        ? globalThis.Number(object.day_of_week)
+        : 0,
+      hourOfDay: isSet(object.hourOfDay)
+        ? globalThis.Number(object.hourOfDay)
+        : isSet(object.hour_of_day)
+        ? globalThis.Number(object.hour_of_day)
+        : 0,
+      eventCount: isSet(object.eventCount)
+        ? globalThis.Number(object.eventCount)
+        : isSet(object.event_count)
+        ? globalThis.Number(object.event_count)
+        : 0,
+      modelUsage: isSet(object.modelUsage)
+        ? TokenActivityMeasures.fromJSON(object.modelUsage)
+        : isSet(object.model_usage)
+        ? TokenActivityMeasures.fromJSON(object.model_usage)
+        : undefined,
+      usageUnavailableCount: isSet(object.usageUnavailableCount)
+        ? globalThis.Number(object.usageUnavailableCount)
+        : isSet(object.usage_unavailable_count)
+        ? globalThis.Number(object.usage_unavailable_count)
+        : 0,
+      costUnavailableCount: isSet(object.costUnavailableCount)
+        ? globalThis.Number(object.costUnavailableCount)
+        : isSet(object.cost_unavailable_count)
+        ? globalThis.Number(object.cost_unavailable_count)
+        : 0,
+      toolCalls: isSet(object.toolCalls)
+        ? globalThis.Number(object.toolCalls)
+        : isSet(object.tool_calls)
+        ? globalThis.Number(object.tool_calls)
+        : 0,
+      userMessages: isSet(object.userMessages)
+        ? globalThis.Number(object.userMessages)
+        : isSet(object.user_messages)
+        ? globalThis.Number(object.user_messages)
+        : 0,
+      sessions: isSet(object.sessions) ? globalThis.Number(object.sessions) : 0,
+      activeUsers: isSet(object.activeUsers)
+        ? globalThis.Number(object.activeUsers)
+        : isSet(object.active_users)
+        ? globalThis.Number(object.active_users)
+        : 0,
+      topTool: isSet(object.topTool)
+        ? globalThis.String(object.topTool)
+        : isSet(object.top_tool)
+        ? globalThis.String(object.top_tool)
+        : "",
+    };
+  },
+
+  toJSON(message: ActivityRhythmBucket): unknown {
+    const obj: any = {};
+    if (message.dayOfWeek !== 0) {
+      obj.dayOfWeek = Math.round(message.dayOfWeek);
+    }
+    if (message.hourOfDay !== 0) {
+      obj.hourOfDay = Math.round(message.hourOfDay);
+    }
+    if (message.eventCount !== 0) {
+      obj.eventCount = Math.round(message.eventCount);
+    }
+    if (message.modelUsage !== undefined) {
+      obj.modelUsage = TokenActivityMeasures.toJSON(message.modelUsage);
+    }
+    if (message.usageUnavailableCount !== 0) {
+      obj.usageUnavailableCount = Math.round(message.usageUnavailableCount);
+    }
+    if (message.costUnavailableCount !== 0) {
+      obj.costUnavailableCount = Math.round(message.costUnavailableCount);
+    }
+    if (message.toolCalls !== 0) {
+      obj.toolCalls = Math.round(message.toolCalls);
+    }
+    if (message.userMessages !== 0) {
+      obj.userMessages = Math.round(message.userMessages);
+    }
+    if (message.sessions !== 0) {
+      obj.sessions = Math.round(message.sessions);
+    }
+    if (message.activeUsers !== 0) {
+      obj.activeUsers = Math.round(message.activeUsers);
+    }
+    if (message.topTool !== "") {
+      obj.topTool = message.topTool;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ActivityRhythmBucket>, I>>(base?: I): ActivityRhythmBucket {
+    return ActivityRhythmBucket.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ActivityRhythmBucket>, I>>(object: I): ActivityRhythmBucket {
+    const message = createBaseActivityRhythmBucket();
+    message.dayOfWeek = object.dayOfWeek ?? 0;
+    message.hourOfDay = object.hourOfDay ?? 0;
+    message.eventCount = object.eventCount ?? 0;
+    message.modelUsage = (object.modelUsage !== undefined && object.modelUsage !== null)
+      ? TokenActivityMeasures.fromPartial(object.modelUsage)
+      : undefined;
+    message.usageUnavailableCount = object.usageUnavailableCount ?? 0;
+    message.costUnavailableCount = object.costUnavailableCount ?? 0;
+    message.toolCalls = object.toolCalls ?? 0;
+    message.userMessages = object.userMessages ?? 0;
+    message.sessions = object.sessions ?? 0;
+    message.activeUsers = object.activeUsers ?? 0;
+    message.topTool = object.topTool ?? "";
+    return message;
+  },
+};
+
 function createBaseProjectOverviewRequest(): ProjectOverviewRequest {
   return { organizationId: "", projectId: "", activeAfter: undefined, topSessions: 0 };
 }
@@ -13199,6 +13806,11 @@ export interface AIGatewayService {
    * omitted; today is provisional.
    */
   StreamDailyActivity(request: DailyActivityRequest, metadata?: Metadata): Observable<DailyActivity>;
+  /**
+   * Live weekly activity rhythm: a sparse (weekday, hour) heatmap over a bounded sliding window in an
+   * explicit IANA time zone. Every latest logical event counts; settled model calls add token/cost.
+   */
+  StreamActivityRhythm(request: ActivityRhythmRequest, metadata?: Metadata): Observable<ActivityRhythm>;
   /**
    * Live stream of one project's dashboard bundle: headline totals, model/provider/source mix,
    * and top sessions by cost.
@@ -13244,6 +13856,7 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     this.StreamGitActivitySummary = this.StreamGitActivitySummary.bind(this);
     this.StreamTokenActivitySummary = this.StreamTokenActivitySummary.bind(this);
     this.StreamDailyActivity = this.StreamDailyActivity.bind(this);
+    this.StreamActivityRhythm = this.StreamActivityRhythm.bind(this);
     this.StreamProjectOverview = this.StreamProjectOverview.bind(this);
     this.ListFiles = this.ListFiles.bind(this);
     this.StreamFilesSummary = this.StreamFilesSummary.bind(this);
@@ -13340,6 +13953,12 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     return result.pipe(map((data) => DailyActivity.decode(new BinaryReader(data))));
   }
 
+  StreamActivityRhythm(request: ActivityRhythmRequest, metadata?: Metadata): Observable<ActivityRhythm> {
+    const data = ActivityRhythmRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "StreamActivityRhythm", data, metadata);
+    return result.pipe(map((data) => ActivityRhythm.decode(new BinaryReader(data))));
+  }
+
   StreamProjectOverview(request: ProjectOverviewRequest, metadata?: Metadata): Observable<ProjectOverview> {
     const data = ProjectOverviewRequest.encode(request).finish();
     const result = this.rpc.serverStreamingRequest(this.service, "StreamProjectOverview", data, metadata);

package/proto/gateway/web/v1/ai_gateway_grpc_pb.js

@@ -30,6 +30,28 @@ function deserialize_gateway_web_v1_AISessionSummary(buffer_arg) {
   return proto_gateway_web_v1_ai_gateway_pb.AISessionSummary.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_gateway_web_v1_ActivityRhythm(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_ai_gateway_pb.ActivityRhythm)) {
+    throw new Error('Expected argument of type gateway.web.v1.ActivityRhythm');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_ActivityRhythm(buffer_arg) {
+  return proto_gateway_web_v1_ai_gateway_pb.ActivityRhythm.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gateway_web_v1_ActivityRhythmRequest(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_ai_gateway_pb.ActivityRhythmRequest)) {
+    throw new Error('Expected argument of type gateway.web.v1.ActivityRhythmRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_ActivityRhythmRequest(buffer_arg) {
+  return proto_gateway_web_v1_ai_gateway_pb.ActivityRhythmRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_gateway_web_v1_DailyActivity(arg) {
   if (!(arg instanceof proto_gateway_web_v1_ai_gateway_pb.DailyActivity)) {
     throw new Error('Expected argument of type gateway.web.v1.DailyActivity');
@@ -603,6 +625,19 @@ streamDailyActivity: {
     responseSerialize: serialize_gateway_web_v1_DailyActivity,
     responseDeserialize: deserialize_gateway_web_v1_DailyActivity,
   },
+  // Live weekly activity rhythm: a sparse (weekday, hour) heatmap over a bounded sliding window in an
+// explicit IANA time zone. Every latest logical event counts; settled model calls add token/cost.
+streamActivityRhythm: {
+    path: '/gateway.web.v1.AIGatewayService/StreamActivityRhythm',
+    requestStream: false,
+    responseStream: true,
+    requestType: proto_gateway_web_v1_ai_gateway_pb.ActivityRhythmRequest,
+    responseType: proto_gateway_web_v1_ai_gateway_pb.ActivityRhythm,
+    requestSerialize: serialize_gateway_web_v1_ActivityRhythmRequest,
+    requestDeserialize: deserialize_gateway_web_v1_ActivityRhythmRequest,
+    responseSerialize: serialize_gateway_web_v1_ActivityRhythm,
+    responseDeserialize: deserialize_gateway_web_v1_ActivityRhythm,
+  },
   // Live stream of one project's dashboard bundle: headline totals, model/provider/source mix,
 // and top sessions by cost.
 streamProjectOverview: {