vg-x07df 1.4.0 → 1.5.0

package/dist/index.cjs

@@ -4,9 +4,8 @@ var React = require('react');
 var socket_ioClient = require('socket.io-client');
 var zustand = require('zustand');
 var immer = require('zustand/middleware/immer');
-var mitt = require('mitt');
 var zod = require('zod');
-var componentsReact = require('@livekit/components-react');
+var mitt = require('mitt');
 var livekitClient = require('livekit-client');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -163,96 +162,6 @@ var useRtcStore = zustand.create()(
 );
 var rtcStore = useRtcStore;
 
-// src/state/errors.ts
-function pushError(code, message, context, logger5) {
-  const error = {
-    code,
-    message,
-    timestamp: Date.now(),
-    context
-  };
-  logger5?.("error", message, { code, context });
-  rtcStore.getState().addError(error);
-}
-function clearErrors(predicate) {
-  rtcStore.getState().patch((state) => {
-    if (predicate) {
-      state.errors = state.errors.filter((error) => !predicate(error));
-    } else {
-      state.errors = [];
-    }
-  });
-}
-function pushSocketValidationError(eventType, issues, payload, logger5) {
-  pushError(
-    "SOCKET_PAYLOAD",
-    `Invalid ${eventType} event payload`,
-    { eventType, issues, payload },
-    logger5
-  );
-}
-function pushIdentityGuardError(reason, expected, received, logger5) {
-  pushError(
-    "JOIN_FLOW",
-    // Use new error code
-    `Identity guard failed: ${reason}`,
-    { expected, received },
-    logger5
-  );
-}
-function pushLiveKitConnectError(message, error, logger5) {
-  pushError(
-    "LIVEKIT_CONNECT",
-    `LiveKit connection failed: ${message}`,
-    { originalError: error },
-    logger5
-  );
-}
-function pushStaleEventError(eventType, reason, context, logger5) {
-  pushError(
-    "JOIN_FLOW",
-    // Use new error code
-    `Ignored stale ${eventType} event: ${reason}`,
-    context,
-    logger5
-  );
-}
-function pushApiError(operation, error, logger5) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "API_ERROR",
-    `API ${operation} failed: ${errorMessage}`,
-    { operation, originalError: error },
-    logger5
-  );
-}
-function pushNetworkError(operation, error, logger5) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "NETWORK",
-    `Network error during ${operation}: ${errorMessage}`,
-    { operation, originalError: error },
-    logger5
-  );
-}
-function pushMediaPermissionError(device, error, logger5) {
-  pushError(
-    "MEDIA_PERMISSION",
-    `${device} permission denied`,
-    { device, originalError: error },
-    logger5
-  );
-}
-function pushDeviceError(operation, device, error, logger5) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  pushError(
-    "DEVICE_SWITCH",
-    `Failed to ${operation} ${device}: ${errorMessage}`,
-    { operation, device, originalError: error },
-    logger5
-  );
-}
-
 // src/core/socketio/handlers/base.handler.ts
 var BaseSocketHandler = class {
   constructor(options = {}) {
@@ -266,37 +175,8 @@ var BaseSocketHandler = class {
   }
   async handleRaw(rawData) {
     this.logger.info(`${this.eventName} received`, rawData);
-    const result = this.schema.safeParse(rawData);
-    if (!result.success) {
-      this.logger.error(
-        `${this.eventName} validation failed`,
-        result.error.issues
-      );
-      pushSocketValidationError(
-        this.eventName,
-        result.error.issues,
-        rawData,
-        (level, message, meta) => {
-          switch (level) {
-            case "debug":
-              this.logger.debug(message, meta);
-              break;
-            case "info":
-              this.logger.info(message, meta);
-              break;
-            case "warn":
-              this.logger.warn(message, meta);
-              break;
-            case "error":
-              this.logger.error(message, meta);
-              break;
-          }
-        }
-      );
-      return;
-    }
     try {
-      await this.handle(result.data);
+      await this.handle(JSON.parse(JSON.stringify(rawData)));
       this.logger.debug(`${this.eventName} handled successfully`);
     } catch (error) {
       this.logger.error(`${this.eventName} handler error`, error);
@@ -310,52 +190,6 @@ var BaseSocketHandler = class {
     return this.options.livekit;
   }
 };
-var EventBus = class {
-  constructor() {
-    this.emitter = mitt__default.default();
-  }
-  on(eventType, handler) {
-    const wrappedHandler = (event) => {
-      handler(event);
-    };
-    this.emitter.on(eventType.toString(), wrappedHandler);
-    return {
-      unsubscribe: () => {
-        this.emitter.off(eventType.toString(), wrappedHandler);
-      }
-    };
-  }
-  emit(eventType, payload) {
-    const event = {
-      type: eventType.toString(),
-      payload,
-      timestamp: Date.now()
-    };
-    this.emitter.emit(eventType.toString(), event);
-  }
-  off(eventType) {
-    this.emitter.off(eventType.toString());
-  }
-  removeAllListeners() {
-    this.emitter.all.clear();
-  }
-};
-var eventBus = new EventBus();
-
-// src/core/events/types.ts
-var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
-  SdkEventType2["CALL_INITIATED"] = "call:initiated";
-  SdkEventType2["CALL_INCOMING"] = "call:incoming";
-  SdkEventType2["CALL_DECLINED"] = "call:declined";
-  SdkEventType2["CALL_ENDED"] = "call:ended";
-  SdkEventType2["CALL_CANCELED"] = "call:canceled";
-  SdkEventType2["CALL_TIMEOUT"] = "call:timeout";
-  SdkEventType2["JOIN_INFO_RECEIVED"] = "join-info:received";
-  SdkEventType2["CALL_STARTED"] = "call:started";
-  SdkEventType2["PARTICIPANT_UPDATED"] = "participant:updated";
-  SdkEventType2["PARTICIPANT_INVITED"] = "participant:invited";
-  return SdkEventType2;
-})(SdkEventType || {});
 var callCancelledSchema = zod.z.object({
   callId: zod.z.string(),
   status: zod.z.literal("cancelled"),
@@ -372,7 +206,7 @@ var callCreatedSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   participants: zod.z.array(zod.z.object({
     firstName: zod.z.string().nullable(),
@@ -380,7 +214,7 @@ var callCreatedSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict())
 }).strict();
 var callEndedSchema = zod.z.object({
@@ -391,6 +225,7 @@ var callEndedSchema = zod.z.object({
 }).strict();
 var callInviteSchema = zod.z.object({
   callId: zod.z.string(),
+  inviteId: zod.z.string(),
   status: zod.z.enum(["pending", "ready", "active", "ended"]),
   caller: zod.z.object({
     firstName: zod.z.string().nullable(),
@@ -398,7 +233,7 @@ var callInviteSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   mode: zod.z.enum(["VIDEO", "AUDIO"])
 }).strict();
@@ -411,7 +246,7 @@ var callInviteAcceptedSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   acceptedAt: zod.z.string()
 }).strict();
@@ -431,7 +266,7 @@ var callInviteDeclinedSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   reason: zod.z.string().optional(),
   declinedAt: zod.z.string()
@@ -445,7 +280,7 @@ var callInviteMissedSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   missedAt: zod.z.string()
 }).strict();
@@ -457,7 +292,7 @@ var callInviteSentSchema = zod.z.object({
     username: zod.z.string().nullable(),
     email: zod.z.string().nullable(),
     profilePhoto: zod.z.string().nullable(),
-    userId: zod.z.string()
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
   }).strict(),
   status: zod.z.literal("sent")
 }).strict();
@@ -488,6 +323,22 @@ var callParticipantAddedSchema = zod.z.object({
     joinState: zod.z.enum(["not_joined", "joined"])
   }).strict()
 }).strict();
+var callReadySchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.literal("ready"),
+  participant: zod.z.object({
+    firstName: zod.z.string().nullable(),
+    lastName: zod.z.string().nullable(),
+    username: zod.z.string().nullable(),
+    email: zod.z.string().nullable(),
+    profilePhoto: zod.z.string().nullable(),
+    userId: zod.z.union([zod.z.string(), zod.z.number()])
+  }).strict(),
+  joinInfo: zod.z.object({
+    token: zod.z.string(),
+    lkUrl: zod.z.string()
+  }).strict()
+}).strict();
 var callRoomStartedSchema = zod.z.object({
   callId: zod.z.string(),
   roomName: zod.z.string(),
@@ -495,103 +346,294 @@ var callRoomStartedSchema = zod.z.object({
   status: zod.z.literal("active")
 }).strict();
 
-// src/core/socketio/handlers/invite.handler.ts
-var InviteHandler = class extends BaseSocketHandler {
+// src/state/errors.ts
+function pushError(code, message, context, logger4) {
+  const error = {
+    code,
+    message,
+    timestamp: Date.now(),
+    context
+  };
+  logger4?.("error", message, { code, context });
+  rtcStore.getState().addError(error);
+}
+function clearErrors(predicate) {
+  rtcStore.getState().patch((state) => {
+    if (predicate) {
+      state.errors = state.errors.filter((error) => !predicate(error));
+    } else {
+      state.errors = [];
+    }
+  });
+}
+function pushSocketValidationError(eventType, issues, payload, logger4) {
+  pushError(
+    "SOCKET_PAYLOAD",
+    `Invalid ${eventType} event payload`,
+    { eventType, issues, payload },
+    logger4
+  );
+}
+function pushIdentityGuardError(reason, expected, received, logger4) {
+  pushError(
+    "JOIN_FLOW",
+    // Use new error code
+    `Identity guard failed: ${reason}`,
+    { expected, received },
+    logger4
+  );
+}
+function pushLiveKitConnectError(message, error, logger4) {
+  pushError(
+    "LIVEKIT_CONNECT",
+    `LiveKit connection failed: ${message}`,
+    { originalError: error },
+    logger4
+  );
+}
+function pushStaleEventError(eventType, reason, context, logger4) {
+  pushError(
+    "JOIN_FLOW",
+    // Use new error code
+    `Ignored stale ${eventType} event: ${reason}`,
+    context,
+    logger4
+  );
+}
+function pushApiError(operation, error, logger4) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "API_ERROR",
+    `API ${operation} failed: ${errorMessage}`,
+    { operation, originalError: error },
+    logger4
+  );
+}
+function pushNetworkError(operation, error, logger4) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "NETWORK",
+    `Network error during ${operation}: ${errorMessage}`,
+    { operation, originalError: error },
+    logger4
+  );
+}
+function pushMediaPermissionError(device, error, logger4) {
+  pushError(
+    "MEDIA_PERMISSION",
+    `${device} permission denied`,
+    { device, originalError: error },
+    logger4
+  );
+}
+function pushDeviceError(operation, device, error, logger4) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  pushError(
+    "DEVICE_SWITCH",
+    `Failed to ${operation} ${device}: ${errorMessage}`,
+    { operation, device, originalError: error },
+    logger4
+  );
+}
+var EventBus = class {
+  constructor() {
+    this.emitter = mitt__default.default();
+  }
+  on(eventType, handler) {
+    const wrappedHandler = (event) => {
+      handler(event);
+    };
+    this.emitter.on(eventType.toString(), wrappedHandler);
+    return {
+      unsubscribe: () => {
+        this.emitter.off(eventType.toString(), wrappedHandler);
+      }
+    };
+  }
+  emit(eventType, payload) {
+    const event = {
+      type: eventType.toString(),
+      payload,
+      timestamp: Date.now()
+    };
+    this.emitter.emit(eventType.toString(), event);
+  }
+  off(eventType) {
+    this.emitter.off(eventType.toString());
+  }
+  removeAllListeners() {
+    this.emitter.all.clear();
+  }
+};
+var eventBus = new EventBus();
+
+// src/core/events/types.ts
+var SdkEventType = /* @__PURE__ */ ((SdkEventType2) => {
+  SdkEventType2["CALL_INITIATED"] = "call:initiated";
+  SdkEventType2["CALL_INCOMING"] = "call:incoming";
+  SdkEventType2["CALL_DECLINED"] = "call:declined";
+  SdkEventType2["CALL_ENDED"] = "call:ended";
+  SdkEventType2["CALL_CANCELED"] = "call:canceled";
+  SdkEventType2["CALL_TIMEOUT"] = "call:timeout";
+  SdkEventType2["JOIN_INFO_RECEIVED"] = "join-info:received";
+  SdkEventType2["CALL_STARTED"] = "call:started";
+  SdkEventType2["PARTICIPANT_UPDATED"] = "participant:updated";
+  SdkEventType2["PARTICIPANT_INVITED"] = "participant:invited";
+  return SdkEventType2;
+})(SdkEventType || {});
+
+// src/core/socketio/handlers/call-cancelled.handler.ts
+var SessionCancelledHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call:invite";
-    this.schema = callInviteSchema;
+    this.eventName = "call:cancelled";
+    this.schema = callCancelledSchema;
   }
   handle(data) {
-    this.logger.info("Incoming call invitation", {
+    const currentState = rtcStore.getState();
+    this.logger.info("Call session cancelled", {
       callId: data.callId,
-      caller: data.caller.userId,
-      mode: data.mode
+      status: data.status
     });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:cancelled", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring cancel event for different call", {
+        callId: data.callId
+      });
+      return;
+    }
     this.updateStore((state) => {
-      state.incomingInvite = {
-        callId: data.callId,
-        caller: {
-          userId: data.caller.userId,
-          firstName: data.caller.firstName,
-          lastName: data.caller.lastName,
-          username: data.caller.username,
-          email: data.caller.email,
-          profilePhoto: data.caller.profilePhoto
-        },
-        mode: data.mode
-      };
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
+      state.room.participants = {};
+    });
+    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
+      callId: data.callId,
+      reason: "cancelled by host",
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session cleared due to cancellation");
+  }
+};
+
+// src/core/socketio/handlers/call-created.handler.ts
+var SessionCreatedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:created";
+    this.schema = callCreatedSchema;
+  }
+  handle(data) {
+    this.logger.info("Call session created", {
+      callId: data.callId,
+      roomName: data.roomName,
+      host: data.host.userId,
+      participantCount: data.participants.length
+    });
+    this.updateStore((state) => {
+      state.initiated = true;
       state.session = {
         id: data.callId,
         status: "pending",
-        mode: data.mode,
-        role: "PARTICIPANT"
+        mode: "VIDEO",
+        role: "HOST"
       };
+      state.outgoingInvites = {};
     });
-    eventBus.emit("call:incoming" /* CALL_INCOMING */, {
+    eventBus.emit("call:initiated" /* CALL_INITIATED */, {
       callId: data.callId,
-      caller: {
-        id: data.caller.userId,
-        firstName: data.caller.firstName,
-        lastName: data.caller.lastName,
-        avatarUrl: data.caller.profilePhoto
-      },
-      type: data.mode,
+      participants: data.participants.map((p) => p.userId),
+      type: "VIDEO",
+      // Default, TODO: get from API request context
       timestamp: Date.now()
     });
-    this.logger.debug("Incoming invite state updated");
+    this.logger.debug("Session created for outbound call");
   }
 };
 
-// src/core/socketio/handlers/invite-sent.handler.ts
-var InviteSentHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/call-ended.handler.ts
+var SessionEndedHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call:inviteSent";
-    this.schema = callInviteSentSchema;
+    this.eventName = "call:ended";
+    this.schema = callEndedSchema;
   }
   handle(data) {
     const currentState = rtcStore.getState();
-    this.logger.info("Invitation sent to participant", {
+    this.logger.info("Call session ended", {
       callId: data.callId,
-      invitee: data.invitee.userId
+      endedBy: data.endedByUserId,
+      reason: data.reason
     });
     if (currentState.session?.id !== data.callId) {
-      pushStaleEventError("call:inviteSent", "callId mismatch", {
+      pushStaleEventError("call:ended", "callId mismatch", {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring invite sent for different call", { callId: data.callId });
+      this.logger.warn("Ignoring end event for different call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
-      const userId = data.invitee.userId;
-      state.outgoingInvites[userId] = {
-        userId,
-        status: "sent",
-        participant: {
-          userId: data.invitee.userId,
-          firstName: data.invitee.firstName,
-          lastName: data.invitee.lastName,
-          username: data.invitee.username,
-          email: data.invitee.email,
-          profilePhoto: data.invitee.profilePhoto
-        }
-      };
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
+      state.room.participants = {};
     });
-    eventBus.emit("participant:invited" /* PARTICIPANT_INVITED */, {
+    if (this.livekit) {
+      this.livekit.disconnect().catch((error) => {
+        this.logger.error("Error disconnecting from LiveKit", { error });
+      });
+    }
+    eventBus.emit("call:ended" /* CALL_ENDED */, {
       callId: data.callId,
-      participant: {
-        id: data.invitee.userId,
-        firstName: data.invitee.firstName,
-        lastName: data.invitee.lastName,
-        avatarUrl: data.invitee.profilePhoto
-      },
+      endedBy: data.endedByUserId,
+      reason: "user",
       timestamp: Date.now()
     });
-    this.logger.debug("Outgoing invite tracked", {
-      userId: data.invitee.userId
+    this.logger.debug("Session cleared and LiveKit disconnected");
+  }
+};
+
+// src/core/socketio/handlers/call-missed.handler.ts
+var SessionMissedHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:missed";
+    this.schema = callMissedSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Call missed by all participants", {
+      callId: data.callId
     });
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:missed", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring missed call for different session", {
+        callId: data.callId
+      });
+      return;
+    }
+    this.updateStore((state) => {
+      state.initiated = false;
+      state.session = null;
+      state.outgoingInvites = {};
+      state.room.participants = {};
+    });
+    eventBus.emit("call:timeout" /* CALL_TIMEOUT */, {
+      callId: data.callId,
+      reason: "All participants missed/declined",
+      timestamp: Date.now()
+    });
+    this.logger.debug("Session cleared - call was missed by all");
   }
 };
 
@@ -613,13 +655,16 @@ var InviteAcceptedHandler = class extends BaseSocketHandler {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring accept event for different call", { callId: data.callId });
+      this.logger.warn("Ignoring accept event for different call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
       if (state.session && data.status) {
         state.session.status = data.status;
       }
+      console.log("state.session.status", state.session.status, data.status);
       const userId = data.participant.userId;
       if (state.outgoingInvites[userId]) {
         state.outgoingInvites[userId].status = "accepted";
@@ -644,6 +689,39 @@ var InviteAcceptedHandler = class extends BaseSocketHandler {
   }
 };
 
+// src/core/socketio/handlers/invite-cancelled.handler.ts
+var InviteCancelledHandler = class extends BaseSocketHandler {
+  constructor() {
+    super(...arguments);
+    this.eventName = "call:inviteCancelled";
+    this.schema = callInviteCancelledSchema;
+  }
+  handle(data) {
+    const currentState = rtcStore.getState();
+    this.logger.info("Invitation cancelled by host", {
+      callId: data.callId,
+      cancelledBy: data.cancelledByUserId,
+      reason: data.reason
+    });
+    if (currentState.incomingInvite?.callId !== data.callId) {
+      this.logger.debug("Ignoring cancelled invite for different call", {
+        callId: data.callId
+      });
+      return;
+    }
+    this.updateStore((state) => {
+      state.incomingInvite = null;
+      state.session = null;
+    });
+    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
+      callId: data.callId,
+      reason: data.reason,
+      timestamp: Date.now()
+    });
+    this.logger.debug("Incoming invite cleared due to cancellation");
+  }
+};
+
 // src/core/socketio/handlers/invite-declined.handler.ts
 var InviteDeclinedHandler = class extends BaseSocketHandler {
   constructor() {
@@ -663,7 +741,9 @@ var InviteDeclinedHandler = class extends BaseSocketHandler {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring decline event for different call", { callId: data.callId });
+      this.logger.warn("Ignoring decline event for different call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
@@ -715,7 +795,9 @@ var InviteMissedHandler = class extends BaseSocketHandler {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring missed invite for different call", { callId: data.callId });
+      this.logger.warn("Ignoring missed invite for different call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
@@ -743,185 +825,111 @@ var InviteMissedHandler = class extends BaseSocketHandler {
   }
 };
 
-// src/core/socketio/handlers/invite-cancelled.handler.ts
-var InviteCancelledHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/invite-sent.handler.ts
+var InviteSentHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call:inviteCancelled";
-    this.schema = callInviteCancelledSchema;
+    this.eventName = "call:inviteSent";
+    this.schema = callInviteSentSchema;
   }
   handle(data) {
     const currentState = rtcStore.getState();
-    this.logger.info("Invitation cancelled by host", {
+    this.logger.info("Invitation sent to participant", {
       callId: data.callId,
-      cancelledBy: data.cancelledByUserId,
-      reason: data.reason
+      invitee: data.invitee.userId
     });
-    if (currentState.incomingInvite?.callId !== data.callId) {
-      this.logger.debug("Ignoring cancelled invite for different call", {
+    if (currentState.session?.id !== data.callId) {
+      pushStaleEventError("call:inviteSent", "callId mismatch", {
+        eventCallId: data.callId,
+        sessionCallId: currentState.session?.id
+      });
+      this.logger.warn("Ignoring invite sent for different call", {
         callId: data.callId
       });
       return;
     }
     this.updateStore((state) => {
-      state.incomingInvite = null;
-      state.session = null;
+      const userId = data.invitee.userId;
+      state.outgoingInvites[userId] = {
+        userId,
+        status: "sent",
+        participant: {
+          userId: data.invitee.userId,
+          firstName: data.invitee.firstName,
+          lastName: data.invitee.lastName,
+          username: data.invitee.username,
+          email: data.invitee.email,
+          profilePhoto: data.invitee.profilePhoto
+        }
+      };
     });
-    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
+    eventBus.emit("participant:invited" /* PARTICIPANT_INVITED */, {
       callId: data.callId,
-      reason: data.reason,
+      participant: {
+        id: data.invitee.userId,
+        firstName: data.invitee.firstName,
+        lastName: data.invitee.lastName,
+        avatarUrl: data.invitee.profilePhoto
+      },
       timestamp: Date.now()
     });
-    this.logger.debug("Incoming invite cleared due to cancellation");
+    this.logger.debug("Outgoing invite tracked", {
+      userId: data.invitee.userId
+    });
   }
 };
 
-// src/core/socketio/handlers/call-created.handler.ts
-var SessionCreatedHandler = class extends BaseSocketHandler {
+// src/core/socketio/handlers/invite.handler.ts
+var InviteHandler = class extends BaseSocketHandler {
   constructor() {
     super(...arguments);
-    this.eventName = "call:created";
-    this.schema = callCreatedSchema;
+    this.eventName = "call:invite";
+    this.schema = callInviteSchema;
   }
   handle(data) {
-    this.logger.info("Call session created", {
+    this.logger.info("Incoming call invitation", {
       callId: data.callId,
-      roomName: data.roomName,
-      host: data.host.userId,
-      participantCount: data.participants.length
+      caller: data.caller.userId,
+      mode: data.mode
     });
     this.updateStore((state) => {
-      state.initiated = true;
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(now.getTime() + 3e4);
+      state.incomingInvite = {
+        callId: data.callId,
+        inviteId: data.inviteId,
+        caller: {
+          userId: data.caller.userId,
+          role: "HOST",
+          firstName: data.caller.firstName ?? "",
+          lastName: data.caller.lastName ?? "",
+          username: data.caller.username ?? "",
+          email: data.caller.email ?? "",
+          profilePhoto: data.caller.profilePhoto ?? ""
+        },
+        mode: data.mode,
+        expiresAt: expiresAt.toISOString(),
+        expiresInMs: 3e4
+      };
       state.session = {
         id: data.callId,
         status: "pending",
-        mode: "VIDEO",
-        role: "HOST"
+        mode: data.mode,
+        role: "PARTICIPANT"
       };
-      state.outgoingInvites = {};
-    });
-    eventBus.emit("call:initiated" /* CALL_INITIATED */, {
-      callId: data.callId,
-      participants: data.participants.map((p) => p.userId),
-      type: "VIDEO",
-      // Default, TODO: get from API request context
-      timestamp: Date.now()
-    });
-    this.logger.debug("Session created for outbound call");
-  }
-};
-
-// src/core/socketio/handlers/call-ended.handler.ts
-var SessionEndedHandler = class extends BaseSocketHandler {
-  constructor() {
-    super(...arguments);
-    this.eventName = "call:ended";
-    this.schema = callEndedSchema;
-  }
-  handle(data) {
-    const currentState = rtcStore.getState();
-    this.logger.info("Call session ended", {
-      callId: data.callId,
-      endedBy: data.endedByUserId,
-      reason: data.reason
-    });
-    if (currentState.session?.id !== data.callId) {
-      pushStaleEventError("call:ended", "callId mismatch", {
-        eventCallId: data.callId,
-        sessionCallId: currentState.session?.id
-      });
-      this.logger.warn("Ignoring end event for different call", { callId: data.callId });
-      return;
-    }
-    this.updateStore((state) => {
-      state.initiated = false;
-      state.session = null;
-      state.outgoingInvites = {};
-      state.room.participants = {};
-    });
-    if (this.livekit) {
-      this.livekit.disconnect().catch((error) => {
-        this.logger.error("Error disconnecting from LiveKit", { error });
-      });
-    }
-    eventBus.emit("call:ended" /* CALL_ENDED */, {
-      callId: data.callId,
-      endedBy: data.endedByUserId,
-      reason: "user",
-      timestamp: Date.now()
-    });
-    this.logger.debug("Session cleared and LiveKit disconnected");
-  }
-};
-
-// src/core/socketio/handlers/call-cancelled.handler.ts
-var SessionCancelledHandler = class extends BaseSocketHandler {
-  constructor() {
-    super(...arguments);
-    this.eventName = "call:cancelled";
-    this.schema = callCancelledSchema;
-  }
-  handle(data) {
-    const currentState = rtcStore.getState();
-    this.logger.info("Call session cancelled", {
-      callId: data.callId,
-      status: data.status
-    });
-    if (currentState.session?.id !== data.callId) {
-      pushStaleEventError("call:cancelled", "callId mismatch", {
-        eventCallId: data.callId,
-        sessionCallId: currentState.session?.id
-      });
-      this.logger.warn("Ignoring cancel event for different call", { callId: data.callId });
-      return;
-    }
-    this.updateStore((state) => {
-      state.initiated = false;
-      state.session = null;
-      state.outgoingInvites = {};
-      state.room.participants = {};
-    });
-    eventBus.emit("call:canceled" /* CALL_CANCELED */, {
-      callId: data.callId,
-      reason: "cancelled by host",
-      timestamp: Date.now()
-    });
-    this.logger.debug("Session cleared due to cancellation");
-  }
-};
-
-// src/core/socketio/handlers/call-missed.handler.ts
-var SessionMissedHandler = class extends BaseSocketHandler {
-  constructor() {
-    super(...arguments);
-    this.eventName = "call:missed";
-    this.schema = callMissedSchema;
-  }
-  handle(data) {
-    const currentState = rtcStore.getState();
-    this.logger.info("Call missed by all participants", {
-      callId: data.callId
-    });
-    if (currentState.session?.id !== data.callId) {
-      pushStaleEventError("call:missed", "callId mismatch", {
-        eventCallId: data.callId,
-        sessionCallId: currentState.session?.id
-      });
-      this.logger.warn("Ignoring missed call for different session", { callId: data.callId });
-      return;
-    }
-    this.updateStore((state) => {
-      state.initiated = false;
-      state.session = null;
-      state.outgoingInvites = {};
-      state.room.participants = {};
     });
-    eventBus.emit("call:timeout" /* CALL_TIMEOUT */, {
+    eventBus.emit("call:incoming" /* CALL_INCOMING */, {
       callId: data.callId,
-      reason: "All participants missed/declined",
+      caller: {
+        id: data.caller.userId,
+        firstName: data.caller.firstName,
+        lastName: data.caller.lastName,
+        avatarUrl: data.caller.profilePhoto
+      },
+      type: data.mode,
       timestamp: Date.now()
     });
-    this.logger.debug("Session cleared - call was missed by all");
+    this.logger.debug("Incoming invite state updated");
   }
 };
 
@@ -944,7 +952,9 @@ var JoinInfoHandler = class extends BaseSocketHandler {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring join info for unknown call", { callId: data.callId });
+      this.logger.warn("Ignoring join info for unknown call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
@@ -988,7 +998,9 @@ var ParticipantAddedHandler = class extends BaseSocketHandler {
         eventCallId: data.callId,
         sessionCallId: currentState.session?.id
       });
-      this.logger.warn("Ignoring participant added for different call", { callId: data.callId });
+      this.logger.warn("Ignoring participant added for different call", {
+        callId: data.callId
+      });
       return;
     }
     this.updateStore((state) => {
@@ -1674,7 +1686,8 @@ var CallsService = class {
   static postSignalCallsByCallIdAccept(data) {
     const {
       callId,
-      appId
+      appId,
+      requestBody
     } = data;
     return request(OpenAPI, {
       method: "POST",
@@ -1685,6 +1698,8 @@ var CallsService = class {
       query: {
         appId
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         400: `Invalid request`,
         401: `Authentication required`,
@@ -1905,12 +1920,12 @@ var OpenApiConfigService = class _OpenApiConfigService {
       if (headers instanceof Headers) {
         authHeader = headers.get("Authorization") || null;
       } else if (headers && typeof headers === "object") {
-        authHeader = headers["Authorization"] || null;
+        authHeader = headers.Authorization || null;
       }
       if (authHeader) {
         logger2.debug("API Request with Authorization header", {
           hasAuth: true,
-          authPrefix: authHeader.substring(0, 20) + "..."
+          authPrefix: `${authHeader.substring(0, 20)}...`
         });
       } else {
         logger2.warn("API Request WITHOUT Authorization header", {
@@ -1937,7 +1952,7 @@ var OpenApiConfigService = class _OpenApiConfigService {
           logger2.warn("Token provider returned empty token");
         } else {
           logger2.debug("Token resolved successfully", {
-            tokenPrefix: token.substring(0, 10) + "..."
+            tokenPrefix: `${token.substring(0, 10)}...`
           });
         }
         return token;
@@ -1966,75 +1981,123 @@ var OpenApiConfigService = class _OpenApiConfigService {
 var apiConfig = OpenApiConfigService.getInstance();
 
 // src/services/calls.service.ts
-var logger3 = createLogger("calls-service");
 function createCallsService(config) {
   const { appId } = config;
-  const ensureApiConfigured = () => {
-    if (!apiConfig.isConfigured()) {
-      logger3.error("API not configured before making call service request");
-      throw new Error(
-        "API configuration missing. Ensure the SDK is properly initialized."
-      );
-    }
-  };
   async function initiate(params) {
-    ensureApiConfigured();
     const requestBody = {
-      mode: params.mode || "AUDIO",
-      participants: params.invitees.map((userId) => ({ userId }))
+      participants: params.invitees.map((userId) => ({ userId: String(userId) }))
     };
     if (params.callId) {
       requestBody.callId = params.callId;
+    } else {
+      requestBody.mode = params.mode || "AUDIO";
     }
-    return CallsService.postSignalCallsInvite({
+    const response = await CallsService.postSignalCallsInvite({
       appId,
       requestBody
     });
+    rtcStore.getState().patch((state) => {
+      for (const participant of response.participants) {
+        if (participant.userId) {
+          state.outgoingInvites[participant.userId] = {
+            userId: participant.userId,
+            status: "sent",
+            participant: {
+              userId: participant.userId,
+              role: participant.role,
+              firstName: participant.firstName ?? "",
+              lastName: participant.lastName ?? "",
+              username: participant.username ?? "",
+              email: participant.email ?? "",
+              profilePhoto: participant.profilePhoto ?? ""
+            }
+          };
+        }
+      }
+      if (!params.callId) {
+        state.initiated = true;
+        state.session = {
+          id: response.callId,
+          status: response.status.toLowerCase(),
+          mode: "AUDIO",
+          role: "HOST"
+        };
+      }
+      if (response.joinInfo && state.session) {
+        state.session.livekitInfo = {
+          token: response.joinInfo.token,
+          roomName: state.session.id,
+          url: response.joinInfo.lkUrl
+        };
+      }
+    });
+    return response;
   }
-  async function accept(callId) {
-    ensureApiConfigured();
-    rtcStore.setState((state) => {
+  async function accept() {
+    const currentState = rtcStore.getState();
+    if (!currentState.incomingInvite) {
+      throw new Error("No incoming invite to accept");
+    }
+    const { callId, inviteId } = currentState.incomingInvite;
+    rtcStore.getState().patch((state) => {
       state.incomingInvite = null;
     });
-    return CallsService.postSignalCallsByCallIdAccept({
+    const response = await CallsService.postSignalCallsByCallIdAccept({
       callId,
-      appId
+      appId,
+      requestBody: {
+        inviteId
+      }
+    });
+    rtcStore.getState().patch((state) => {
+      if (response.joinInfo && state.session) {
+        state.session.status = "ready";
+        state.session.livekitInfo = {
+          token: response.joinInfo.token,
+          roomName: state.session.id,
+          url: response.joinInfo.lkUrl
+        };
+      }
     });
+    return response;
   }
-  async function decline(callId, reason) {
-    ensureApiConfigured();
-    const payload = {
-      callId,
-      appId
+  async function decline(reason) {
+    const currentState = rtcStore.getState();
+    if (!currentState.incomingInvite) {
+      throw new Error("No incoming invite to decline");
+    }
+    const { callId, inviteId } = currentState.incomingInvite;
+    const requestBody = {
+      inviteId
     };
     if (reason) {
-      payload.requestBody = { reason };
+      requestBody.reason = reason;
     }
-    return CallsService.postSignalCallsByCallIdDecline(payload);
+    return CallsService.postSignalCallsByCallIdDecline({
+      callId,
+      appId,
+      requestBody
+    });
   }
   async function cancel(callId) {
-    ensureApiConfigured();
     return CallsService.postSignalCallsByCallIdCancel({
       callId,
       appId
     });
   }
   async function leave(callId) {
-    ensureApiConfigured();
     return CallsService.postSignalCallsByCallIdLeave({
       callId,
       appId
     });
   }
   async function end(callId) {
-    ensureApiConfigured();
     return CallsService.postSignalCallsByCallIdEnd({
       callId,
       appId
     });
   }
   async function transfer(callId, targetParticipantId, reason) {
-    ensureApiConfigured();
     const requestBody = {
       targetParticipantId
     };
@@ -2048,7 +2111,6 @@ function createCallsService(config) {
     });
   }
   async function kick(callId, participantId, reason) {
-    ensureApiConfigured();
     const requestBody = {
       participantId
     };
@@ -2062,7 +2124,6 @@ function createCallsService(config) {
     });
   }
   async function mute(callId, participantId) {
-    ensureApiConfigured();
     return CallsService.postSignalCallsByCallIdMute({
       callId,
       appId,
@@ -2182,16 +2243,16 @@ function useCallState() {
   };
 }
 
-// src/hooks/useSessionId.ts
-function useSessionId() {
-  return useRtcStore((state) => state.session?.id ?? null);
-}
-
 // src/hooks/useIncomingInvite.ts
 function useIncomingInvite() {
   return useRtcStore((state) => state.incomingInvite);
 }
 
+// src/hooks/useSessionId.ts
+function useSessionId() {
+  return useRtcStore((state) => state.session?.id ?? null);
+}
+
 // src/hooks/useCallActions.ts
 function useCallActions() {
   const sdk = useSdk();
@@ -2217,13 +2278,13 @@ function useCallActions() {
       if (!incomingInvite) {
         throw new Error("No incoming invite to accept");
       }
-      return sdk.calls.accept(incomingInvite.callId);
+      return sdk.calls.accept();
     },
     decline: (reason) => {
       if (!incomingInvite) {
         throw new Error("No incoming invite to decline");
       }
-      return sdk.calls.decline(incomingInvite.callId, reason);
+      return sdk.calls.decline(reason);
     },
     cancel: () => {
       if (!sessionId) {
@@ -2307,10 +2368,11 @@ function useCallInitiated() {
 function useSessionDuration() {
   return 0;
 }
+
+// src/hooks/useParticipantMetadata.ts
 function useParticipantMetadata(participant) {
-  const info = componentsReact.useParticipantInfo({ participant });
   try {
-    const metadata = JSON.parse(info.metadata);
+    const metadata = participant.metadata ? JSON.parse(participant.metadata) : {};
     return {
       userId: metadata.userId,
       role: metadata.role,
@@ -2347,7 +2409,7 @@ function useRoomReady() {
   const { status } = useCallState();
   return livekitInfo !== null && (status === "ready" || status === "active");
 }
-var logger4 = createLogger("useAutoConnectRoom");
+var logger3 = createLogger("useAutoConnectRoom");
 function useAutoConnectRoom(options) {
   const [room] = React.useState(() => new livekitClient.Room(options));
   const isReady = useRoomReady();
@@ -2355,7 +2417,9 @@ function useAutoConnectRoom(options) {
   React.useEffect(() => {
     if (isReady && livekitInfo) {
       room.connect(livekitInfo.url, livekitInfo.token).catch((error) => {
-        logger4.error("Failed to connect to LiveKit room", error);
+        logger3.error("Failed to connect to LiveKit room", error);
+      }).then(() => {
+        room.localParticipant.setMicrophoneEnabled(true);
       });
     } else if (room.state === livekitClient.ConnectionState.Connected) {
       room.disconnect();
@@ -2382,6 +2446,7 @@ exports.callInviteSentSchema = callInviteSentSchema;
 exports.callJoinInfoSchema = callJoinInfoSchema;
 exports.callMissedSchema = callMissedSchema;
 exports.callParticipantAddedSchema = callParticipantAddedSchema;
+exports.callReadySchema = callReadySchema;
 exports.callRoomStartedSchema = callRoomStartedSchema;
 exports.clearErrors = clearErrors;
 exports.eventBus = eventBus;