@tencent-rtc/trtc-agent-skills 0.1.0

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/types.ts

@@ -0,0 +1,77 @@
+import type { RoomParticipant } from 'tuikit-atomicx-vue3';
+
+export type ConsultationRole = 'primaryDoctor' | 'consultingDoctor' | 'patient';
+
+export interface ConsultationPermissions {
+  canInviteDoctor: boolean;
+  canCancelInvite: boolean;
+  canKickMember: boolean;
+  canManagePatientDevice: boolean;
+}
+
+export interface ConsultationVideoMember {
+  userId: string;
+  displayName: string;
+  avatarText: string;
+  role: ConsultationRole;
+  roleLabel: string;
+  participant: RoomParticipant;
+  videoReady: boolean;
+  isSelf: boolean;
+}
+
+export interface ConsultationMemberCard {
+  userId: string;
+  userName: string;
+  isPatient: boolean;
+  roleLabel: string;
+  roleClass: string;
+  avatarClass: string;
+  cameraOn: boolean;
+  microphoneOn: boolean;
+  pending: boolean;
+  cancelable: boolean;
+}
+
+export interface DoctorInviteListItem {
+  userId: string;
+  userName: string;
+  department?: string;
+  title?: string;
+  inviteStatus: 'idle' | 'pending' | 'joined';
+}
+
+export interface ConsultationTranscriptItem {
+  segmentId: string;
+  speakerUserId: string;
+  sourceText: string;
+  timestamp: number;
+}
+
+export interface ConsultationCallEvent {
+  call?: {
+    roomId?: string;
+    callee?: {
+      userId?: string;
+    };
+    inviter?: {
+      userId?: string;
+    };
+    caller?: {
+      userId?: string;
+    };
+  };
+  roomInfo?: {
+    roomId?: string;
+  };
+  inviter?: {
+    userId?: string;
+  };
+  senderUserId?: string;
+}
+
+export interface ConsultationParticipantEvent {
+  userInfo?: {
+    userId?: string;
+  };
+}

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/useConsultationChat.ts

@@ -0,0 +1,97 @@
+import { computed, ref, type Ref } from 'vue';
+import {
+  useConversationListState,
+  useMessageInputState,
+  useMessageListState,
+} from 'tuikit-atomicx-vue3';
+import {
+  normalizeConsultationTimestamp,
+  type ConsultationMessageLike,
+} from '@/features/consultation/utils';
+import { medicalT } from '@/i18n/medicalTranslate';
+
+export function useConsultationChat(options: {
+  peerUserId: Ref<string | undefined>;
+  sessionStartedAt: Ref<number>;
+  emptyErrorText?: string;
+}) {
+  const { createC2CConversation, setActiveConversation, activeConversation } =
+    useConversationListState();
+  const { messageList } = useMessageListState();
+  const { sendMessage } = useMessageInputState();
+
+  const chatInput = ref('');
+  const chatError = ref('');
+  const isSendingMessage = ref(false);
+
+  const chatMessages = computed(() =>
+    ([...(messageList.value ?? [])] as unknown as ConsultationMessageLike[])
+      .filter(
+        item =>
+          normalizeConsultationTimestamp((item as { time?: number }).time) >=
+          options.sessionStartedAt.value
+      )
+      .slice(-120)
+  );
+
+  async function ensureChatConversation() {
+    chatError.value = '';
+    if (!options.peerUserId.value) {
+      return;
+    }
+    try {
+      const conversation = await createC2CConversation(options.peerUserId.value);
+      await setActiveConversation(conversation.conversationID);
+    } catch (error) {
+      chatError.value =
+        error instanceof Error
+          ? error.message
+          : options.emptyErrorText || medicalT('Medical.Chat.SessionInitFailed');
+    }
+  }
+
+  async function handleSendMessage() {
+    const content = chatInput.value.trim();
+    if (!content || isSendingMessage.value) {
+      return;
+    }
+    isSendingMessage.value = true;
+    chatError.value = '';
+    try {
+      if (!activeConversation.value?.conversationID) {
+        await ensureChatConversation();
+      }
+      await sendMessage(content);
+      chatInput.value = '';
+    } catch (error) {
+      chatError.value =
+        error instanceof Error
+          ? error.message
+          : medicalT('Medical.Chat.MessageSendFailed');
+    } finally {
+      isSendingMessage.value = false;
+    }
+  }
+
+  async function clearChatConversation() {
+    chatInput.value = '';
+    chatError.value = '';
+    isSendingMessage.value = false;
+    try {
+      await setActiveConversation('');
+    } catch {
+      // no-op: clearing local active conversation can fail silently
+    }
+  }
+
+  return {
+    activeConversation,
+    chatInput,
+    chatError,
+    isSendingMessage,
+    chatMessages,
+    ensureChatConversation,
+    handleSendMessage,
+    clearChatConversation,
+  };
+}

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/useConsultationDevices.ts

@@ -0,0 +1,48 @@
+import { ref } from 'vue';
+import { useUIKit } from '@tencentcloud/uikit-base-component-vue3';
+
+export type DeviceOpenResult =
+  | { status: 'fulfilled'; value: unknown }
+  | { status: 'rejected'; reason: unknown };
+
+export function useConsultationDevices() {
+  const { t } = useUIKit();
+  const devicePermissionHint = ref('');
+
+  function getDeviceErrorHint(deviceLabel: string, error: unknown) {
+    const message = error instanceof Error ? error.message : '';
+    return t('Medical.Device.OpenFailed', {
+      device: deviceLabel,
+      message: message ? t('Medical.Device.ErrorInfo', { message }) : '',
+    });
+  }
+
+  function updateDevicePermissionHint(results: DeviceOpenResult[]) {
+    const failedLabels = results
+      .map((result, index) => ({
+        result,
+        label: index === 0 ? t('Medical.Device.Microphone') : t('Medical.Device.Camera'),
+      }))
+      .filter(
+        item =>
+          item.result.status === 'rejected' ||
+          (item.result.status === 'fulfilled' && item.result.value === false)
+      )
+      .map(item => item.label);
+
+    if (!failedLabels.length) {
+      devicePermissionHint.value = '';
+      return;
+    }
+
+    devicePermissionHint.value = t('Medical.Device.PermissionHint', {
+      devices: failedLabels.join('、'),
+    });
+  }
+
+  return {
+    devicePermissionHint,
+    getDeviceErrorHint,
+    updateDevicePermissionHint,
+  };
+}

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/useConsultationParticipants.ts

@@ -0,0 +1,121 @@
+import { computed, ref, type Ref } from 'vue';
+import { useUIKit } from '@tencentcloud/uikit-base-component-vue3';
+import type { RoomParticipant } from 'tuikit-atomicx-vue3';
+import type { MedicalUser } from '@/services/adapters';
+import type {
+  ConsultationRole,
+  ConsultationVideoMember,
+} from '@/features/consultation/types';
+
+export function useConsultationParticipants(options: {
+  participantList: Ref<RoomParticipant[]>;
+  participantListWithVideo: Ref<RoomParticipant[]>;
+  localParticipant: Ref<RoomParticipant | null | undefined>;
+  primaryDoctorId: Ref<string | undefined>;
+  patientId: Ref<string | undefined>;
+  preferredFocusUserId: Ref<string | undefined>;
+  getDoctorById: (userId: string) => MedicalUser | null;
+  getPatientById: (userId: string) => MedicalUser | null;
+  selfDisplayName?: string;
+}) {
+  const { t } = useUIKit();
+  const focusUserId = ref('');
+
+  function getRoleLabel(role: ConsultationRole) {
+    if (role === 'primaryDoctor') {
+      return t('Medical.Common.AttendingDoctor');
+    }
+    if (role === 'consultingDoctor') {
+      return t('Medical.Common.ConsultingDoctor');
+    }
+    return t('Medical.Common.Patient');
+  }
+
+  function getRoleFromUserId(
+    userId: string,
+    patientId: string | undefined,
+    primaryDoctorId: string | undefined
+  ): ConsultationRole {
+    if (userId === patientId) {
+      return 'patient';
+    }
+    if (userId === primaryDoctorId) {
+      return 'primaryDoctor';
+    }
+    return 'consultingDoctor';
+  }
+
+  const videoReadyUserIdSet = computed(
+    () =>
+      new Set(
+        options.participantListWithVideo.value.map(item => String(item.userId))
+      )
+  );
+
+  const members = computed<ConsultationVideoMember[]>(() =>
+    options.participantList.value.map(item => {
+      const userId = String(item.userId);
+      const isSelf = userId === options.localParticipant.value?.userId;
+      const role: ConsultationRole = getRoleFromUserId(
+        userId,
+        options.patientId.value,
+        options.primaryDoctorId.value
+      );
+      const doctorInfo = options.getDoctorById(userId);
+      const patientInfo = options.getPatientById(userId);
+      const rawDisplayName =
+        item.nameCard ||
+        doctorInfo?.userName ||
+        patientInfo?.userName ||
+        item.userName ||
+        userId;
+      const displayName = isSelf
+        ? options.selfDisplayName ||
+          `${rawDisplayName} (${t('Medical.Common.Me')})`
+        : rawDisplayName;
+
+      return {
+        userId,
+        displayName,
+        avatarText: isSelf
+          ? options.selfDisplayName || t('Medical.Common.Me')
+          : String(rawDisplayName).charAt(0),
+        role,
+        roleLabel: getRoleLabel(role),
+        participant: item,
+        videoReady: videoReadyUserIdSet.value.has(userId),
+        isSelf,
+      };
+    })
+  );
+
+  const mainMember = computed(() => {
+    const list = members.value;
+    return (
+      list.find(item => item.userId === focusUserId.value) ||
+      list.find(item => item.userId === options.preferredFocusUserId.value) ||
+      list.find(
+        item => item.userId === options.localParticipant.value?.userId
+      ) ||
+      list[0] ||
+      null
+    );
+  });
+
+  const thumbnailMembers = computed(() =>
+    members.value.filter(item => item.userId !== mainMember.value?.userId)
+  );
+
+  function focusParticipant(userId: string) {
+    focusUserId.value = userId;
+  }
+
+  return {
+    focusUserId,
+    videoReadyUserIdSet,
+    members,
+    mainMember,
+    thumbnailMembers,
+    focusParticipant,
+  };
+}

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/useConsultationPermissions.ts

@@ -0,0 +1,25 @@
+import { computed, type Ref } from 'vue';
+import type { ConsultationPermissions } from '@/features/consultation/types';
+
+export function useConsultationPermissions(options: {
+  currentUserId: Ref<string | undefined>;
+  primaryDoctorId: Ref<string | undefined>;
+}) {
+  const isPrimaryDoctor = computed(
+    () =>
+      !!options.currentUserId.value &&
+      options.currentUserId.value === options.primaryDoctorId.value
+  );
+
+  const permissions = computed<ConsultationPermissions>(() => ({
+    canInviteDoctor: isPrimaryDoctor.value,
+    canCancelInvite: isPrimaryDoctor.value,
+    canKickMember: isPrimaryDoctor.value,
+    canManagePatientDevice: isPrimaryDoctor.value,
+  }));
+
+  return {
+    isPrimaryDoctor,
+    permissions,
+  };
+}

package/skills/trtc/room-builder/templates/scenarios/medical-consultation/src/features/consultation/utils.ts

@@ -0,0 +1,70 @@
+import { MessageType } from 'tuikit-atomicx-vue3';
+import { medicalT } from '@/i18n/medicalTranslate';
+
+export interface ConsultationMessageLike {
+  ID?: string;
+  flow?: string;
+  time?: number;
+  type?: MessageType;
+  payload?: {
+    text?: string;
+  };
+  getMessageContent?: () => {
+    text?: string;
+  };
+}
+
+export function normalizeConsultationTimestamp(timestamp?: number) {
+  if (!timestamp) {
+    return 0;
+  }
+  return timestamp < 1_000_000_000_000 ? timestamp * 1000 : timestamp;
+}
+
+export function formatConsultationClock(timestamp?: number, withSeconds = true) {
+  const timeValue = normalizeConsultationTimestamp(timestamp);
+  if (!timeValue) {
+    return '';
+  }
+  const date = new Date(timeValue);
+  const hours = `${date.getHours()}`.padStart(2, '0');
+  const minutes = `${date.getMinutes()}`.padStart(2, '0');
+  if (!withSeconds) {
+    return `${hours}:${minutes}`;
+  }
+  const seconds = `${date.getSeconds()}`.padStart(2, '0');
+  return `${hours}:${minutes}:${seconds}`;
+}
+
+export function getConsultationMessageText(message: ConsultationMessageLike) {
+  if (message.type === MessageType.TEXT || !message.type) {
+    if (typeof message.payload?.text === 'string') {
+      return message.payload.text;
+    }
+    const content =
+      typeof message.getMessageContent === 'function'
+        ? message.getMessageContent()
+        : undefined;
+    if (typeof content?.text === 'string') {
+      return content.text;
+    }
+  }
+  if (message.type === MessageType.IMAGE) {
+    return medicalT('Medical.Message.ImageMessage');
+  }
+  if (message.type === MessageType.VIDEO) {
+    return medicalT('Medical.Message.VideoMessage');
+  }
+  if (message.type === MessageType.FILE) {
+    return medicalT('Medical.Message.FileMessage');
+  }
+  return medicalT('Medical.Message.UnsupportedMessage');
+}
+
+export function formatElapsedDuration(seconds: number) {
+  const mins = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return `${mins.toString().padStart(2, '0')}:${secs
+    .toString()
+    .padStart(2, '0')}`;
+}