@pmate/chat-sdk 0.6.3 → 0.7.0

package/lib/index.d.ts

@@ -33,3 +33,5 @@ export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
 export * from "./runtime/activity";
 export * from "./runtime/call";
+export * from "./runtime/presence";
+export * from "./runtime/meeting";

package/lib/index.js

@@ -33,3 +33,5 @@ export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
 export * from "./runtime/activity";
 export * from "./runtime/call";
+export * from "./runtime/presence";
+export * from "./runtime/meeting";

package/lib/runtime/chatClient.d.ts

@@ -1,3 +1,4 @@
+import { type ChatPresence } from "./presence.js";
 import { ChatActivityPublisher, type ActivityTarget, type ChatActivity, type ChatActivityState, type ChatActivityUpdate } from "./activity.js";
 import type { ChatMention } from "../mentions/model";
 import { type BotLoginSession } from "./botAuth.js";
@@ -14,10 +15,17 @@ export type ChatClientOptions = {
     realtimeClient?: RealtimeClient;
     fetchImpl?: typeof fetch;
     onActivityError?: (error: unknown) => void;
+    presence?: {
+        baseUrl?: string;
+    };
     ackTimeoutMs?: number;
 };
 export declare class ChatClient {
     private readonly options;
+    private readonly instanceId;
+    private presence?;
+    private presenceProfiles;
+    private presenceHandlers;
     private connection;
     private readonly connectionHandlers;
     private subscriptions;
@@ -40,6 +48,8 @@ export declare class ChatClient {
     private setConnection;
     private rejectPending;
     private authenticate;
+    watchPresenceProfiles(ids: string[]): void;
+    watchPresence(handler: (items: ChatPresence[]) => void): () => void;
     watchMessages(handler: (message: ChatRuntimeMessage) => void): () => boolean;
     watchActivities(handler: (activities: ChatActivity[]) => void): () => void;
     sendActivity(input: ActivityTarget & {

package/lib/runtime/chatClient.js

@@ -1,3 +1,4 @@
+import { ChatPresenceClient } from "./presence.js";
 import { ChatActivityStore, ChatActivityPublisher, createActivityMessage, parseChatActivity } from "./activity.js";
 import { loginPmateBot } from "./botAuth.js";
 import { parsePmateBotKeyJson } from "./botKey.js";
@@ -7,6 +8,10 @@ const DEFAULT_AUTH_API_BASE_URL = "https://auth-api-v2.pmate.chat";
 const DEFAULT_ACK_TIMEOUT_MS = 5_000;
 export class ChatClient {
     options;
+    instanceId = crypto.randomUUID();
+    presence;
+    presenceProfiles = [];
+    presenceHandlers = new Set();
     connection = "closed";
     connectionHandlers = new Set();
     subscriptions = [];
@@ -55,6 +60,12 @@ export class ChatClient {
         const profileId = await this.resolveProfileId();
         if (generation !== this.generation)
             throw new Error("ChatClient closed");
+        if (this.options.presence && !this.presence) {
+            this.presence = new ChatPresenceClient({ appId: this.options.appId, profileId, instanceId: this.instanceId, token: () => this.session.token, baseUrl: this.options.presence.baseUrl, fetchImpl: this.options.fetchImpl });
+            this.presence.watchProfiles(this.presenceProfiles);
+            this.presence.watch(items => { for (const handler of this.presenceHandlers)
+                handler(items); });
+        }
         if (!this.client) {
             const hubUrl = normalizeWsUrl(this.options.hubUrl ?? DEFAULT_HUB_URL, profileId);
             this.client = new RuntimeWebsocketClient(hubUrl);
@@ -102,6 +113,10 @@ export class ChatClient {
         if (this.connection === state)
             return;
         this.connection = state;
+        if (state === "connected")
+            this.presence?.start();
+        else
+            this.presence?.stop();
         for (const handler of this.connectionHandlers)
             handler(state);
     }
@@ -134,6 +149,12 @@ export class ChatClient {
             }
         }
     }
+    watchPresenceProfiles(ids) { this.presenceProfiles = ids; this.presence?.watchProfiles(ids); }
+    watchPresence(handler) {
+        this.presenceHandlers.add(handler);
+        handler(this.presence?.snapshot() ?? []);
+        return () => { this.presenceHandlers.delete(handler); };
+    }
     watchMessages(handler) {
         this.messageHandlers.add(handler);
         return () => this.messageHandlers.delete(handler);
@@ -230,6 +251,7 @@ export class ChatClient {
             token,
             as: "user",
             profileId,
+            clientInstanceId: this.instanceId,
         }, ChatMsgKind.DM);
         await this.sendAndWaitForAck(auth);
     }

package/lib/runtime/index.d.ts

@@ -6,3 +6,5 @@ export * from "./readerClient.js";
 export * from "./thread.js";
 export * from "./activity.js";
 export * from "./call.js";
+export * from "./presence.js";
+export * from "./meeting";

package/lib/runtime/index.js

@@ -6,3 +6,5 @@ export * from "./readerClient.js";
 export * from "./thread.js";
 export * from "./activity.js";
 export * from "./call.js";
+export * from "./presence.js";
+export * from "./meeting";

package/lib/runtime/meeting.d.ts

@@ -0,0 +1,54 @@
+import type { CallClientOptions } from "./call";
+export type MeetingParticipant = {
+    id: string;
+    profileId: string;
+    muted: boolean;
+    connection: "connecting" | "connected" | "failed";
+    stream?: MediaStream;
+};
+export type MeetingSnapshot = {
+    phase: "idle" | "joining" | "joined" | "ended";
+    groupId?: string;
+    meetingId?: string;
+    selfId?: string;
+    participants: MeetingParticipant[];
+    muted: boolean;
+    sharingId?: string;
+    localScreen?: MediaStream;
+    error?: string;
+};
+/** Small-group mesh (six people maximum), media capture only after explicit join/share. */
+export declare class GroupMeetingClient {
+    private options;
+    private state;
+    private listeners;
+    private ws?;
+    private microphone?;
+    private screen?;
+    private links;
+    private generation;
+    private pendingCapture;
+    private timer?;
+    private heartbeat?;
+    private lastSeen;
+    private iceServers;
+    private queue;
+    constructor(options: CallClientOptions);
+    snapshot(): MeetingSnapshot;
+    subscribe(fn: (s: MeetingSnapshot) => void): () => void;
+    join(groupId: string): Promise<void>;
+    leave(): void;
+    dismiss(): void;
+    close(): void;
+    mute(): void;
+    shareScreen(): Promise<void>;
+    stopSharing(): Promise<void>;
+    private update;
+    private send;
+    private fail;
+    private release;
+    private participant;
+    private link;
+    private syncScreen;
+    private receive;
+}

package/lib/runtime/meeting.js

@@ -0,0 +1,262 @@
+/** Small-group mesh (six people maximum), media capture only after explicit join/share. */
+export class GroupMeetingClient {
+    options;
+    state = { phase: "idle", participants: [], muted: false };
+    listeners = new Set();
+    ws;
+    microphone;
+    screen;
+    links = new Map();
+    generation = 0;
+    pendingCapture = false;
+    timer;
+    heartbeat;
+    lastSeen = 0;
+    iceServers = [];
+    queue = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+    }
+    snapshot() { return this.state; }
+    subscribe(fn) { this.listeners.add(fn); fn(this.state); return () => { this.listeners.delete(fn); }; }
+    async join(groupId) {
+        if (!["idle", "ended"].includes(this.state.phase))
+            return;
+        this.release();
+        const gen = this.generation;
+        this.update({ phase: "joining", groupId, error: undefined });
+        this.timer = setTimeout(() => this.fail("CONNECTION_TIMEOUT"), 30000);
+        try {
+            const stream = await (this.options.mediaDevices ?? navigator.mediaDevices).getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true }, video: false });
+            if (gen !== this.generation) {
+                stream.getTracks().forEach(t => t.stop());
+                return;
+            }
+            this.microphone = stream;
+            for (const t of stream.getAudioTracks())
+                t.onended = () => { if (gen === this.generation)
+                    this.fail("MICROPHONE_DENIED"); };
+            const ws = (this.options.createWebSocket ?? (url => new WebSocket(url)))(this.options.url ?? "wss://calls.pmate.chat/call");
+            this.ws = ws;
+            ws.onopen = () => { if (gen === this.generation)
+                this.send({ type: "auth", mode: "meeting", profileId: this.options.profileId, token: this.options.token }); };
+            ws.onmessage = e => { this.lastSeen = Date.now(); this.queue = this.queue.then(async () => { if (gen === this.generation)
+                await this.receive(JSON.parse(String(e.data)), gen); }).catch(() => { if (gen === this.generation)
+                this.fail("CONNECTION_FAILED"); }); };
+            ws.onerror = () => { };
+            ws.onclose = () => { if (gen === this.generation)
+                this.fail("DISCONNECTED"); };
+        }
+        catch {
+            if (gen === this.generation)
+                this.fail(this.microphone ? "CONNECTION_FAILED" : "MICROPHONE_DENIED");
+        }
+    }
+    leave() { this.send({ type: "room.leave", meetingId: this.state.meetingId }); this.release(); this.update({ phase: "ended" }); }
+    dismiss() { if (this.state.phase === "ended")
+        this.update({ phase: "idle", error: undefined }); }
+    close() { this.leave(); this.listeners.clear(); }
+    mute() { if (this.state.phase !== "joined")
+        return; const muted = !this.state.muted; this.microphone?.getAudioTracks().forEach(t => t.enabled = !muted); this.update({ muted }); this.send({ type: "room.mute", meetingId: this.state.meetingId, muted }); }
+    async shareScreen() {
+        if (this.state.phase !== "joined" || this.pendingCapture)
+            return;
+        if (this.screen)
+            return this.stopSharing();
+        if (this.state.sharingId && this.state.sharingId !== this.state.selfId) {
+            this.update({ error: "SCREEN_BUSY" });
+            return;
+        }
+        const gen = this.generation;
+        this.pendingCapture = true;
+        try {
+            const stream = await (this.options.mediaDevices ?? navigator.mediaDevices).getDisplayMedia({ video: { width: { ideal: 1280, max: 1920 }, height: { ideal: 720, max: 1080 }, frameRate: { ideal: 10, max: 15 } }, audio: false });
+            if (gen !== this.generation) {
+                stream.getTracks().forEach(t => t.stop());
+                return;
+            }
+            this.screen = stream;
+            const track = stream.getVideoTracks()[0];
+            if (!track)
+                throw new Error("No video");
+            track.contentHint = "detail";
+            track.onended = () => { if (gen === this.generation)
+                void this.stopSharing(); };
+            this.send({ type: "room.sharing", meetingId: this.state.meetingId, active: true });
+            this.update({ localScreen: stream, error: undefined });
+        }
+        catch (e) {
+            if (gen === this.generation) {
+                await this.stopSharing();
+                if (!(e instanceof DOMException && e.name === "NotAllowedError"))
+                    this.update({ error: "SCREEN_UNAVAILABLE" });
+            }
+        }
+        finally {
+            if (gen === this.generation)
+                this.pendingCapture = false;
+        }
+    }
+    async stopSharing() {
+        const gen = this.generation;
+        const stream = this.screen;
+        this.screen = undefined;
+        stream?.getTracks().forEach(t => { t.onended = null; t.stop(); });
+        await Promise.all([...this.links.values()].map(l => l.video.sender.replaceTrack(null).catch(() => { })));
+        if (gen !== this.generation)
+            return;
+        this.send({ type: "room.sharing", meetingId: this.state.meetingId, active: false });
+        this.update({ localScreen: undefined });
+    }
+    update(p) { this.state = { ...this.state, ...p }; for (const fn of this.listeners)
+        fn(this.state); }
+    send(m) { if (this.ws?.readyState === 1)
+        this.ws.send(JSON.stringify(m)); }
+    fail(error) { this.leave(); this.update({ error }); }
+    release() {
+        this.generation++;
+        clearTimeout(this.timer);
+        clearInterval(this.heartbeat);
+        this.pendingCapture = false;
+        const ws = this.ws;
+        this.ws = undefined;
+        ws?.close();
+        for (const link of this.links.values()) {
+            clearTimeout(link.timer);
+            link.pc.close();
+        }
+        this.links.clear();
+        for (const stream of [this.microphone, this.screen])
+            stream?.getTracks().forEach(t => { t.onended = null; t.stop(); });
+        this.microphone = undefined;
+        this.screen = undefined;
+        this.update({ participants: [], meetingId: undefined, selfId: undefined, sharingId: undefined, localScreen: undefined, muted: false });
+    }
+    participant(id, patch) { this.update({ participants: this.state.participants.map(p => p.id === id ? { ...p, ...patch } : p) }); }
+    link(id, gen) {
+        const previous = this.links.get(id);
+        if (previous)
+            return previous;
+        const pc = (this.options.createPeerConnection ?? (c => new RTCPeerConnection(c)))({ bundlePolicy: "max-bundle", iceServers: this.iceServers, iceTransportPolicy: this.options.iceTransportPolicy ?? "all" });
+        for (const track of this.microphone.getAudioTracks())
+            pc.addTrack(track, this.microphone);
+        const video = pc.addTransceiver("video", { direction: "sendrecv", sendEncodings: [{ maxBitrate: 800000, maxFramerate: 15 }] });
+        const link = { pc, video, remote: new MediaStream(), candidates: [] };
+        this.links.set(id, link);
+        const current = () => gen === this.generation && this.links.get(id) === link;
+        link.timer = setTimeout(() => { if (current())
+            this.participant(id, { connection: "failed" }); }, 30000);
+        pc.ontrack = e => { if (current()) {
+            link.remote.addTrack(e.track);
+            this.participant(id, { stream: link.remote });
+        } };
+        pc.onicecandidate = e => { if (current() && e.candidate)
+            this.send({ type: "room.ice", meetingId: this.state.meetingId, peerId: id, candidate: e.candidate.toJSON() }); };
+        pc.onconnectionstatechange = () => {
+            if (!current())
+                return;
+            if (pc.connectionState === "connected") {
+                clearTimeout(link.timer);
+                this.participant(id, { connection: "connected" });
+            }
+            else if (["failed", "disconnected", "closed"].includes(pc.connectionState))
+                this.participant(id, { connection: pc.connectionState === "disconnected" ? "connecting" : "failed" });
+        };
+        return link;
+    }
+    async syncScreen() {
+        const track = this.state.sharingId === this.state.selfId ? this.screen?.getVideoTracks()[0] ?? null : null;
+        await Promise.all([...this.links.values()].map(l => l.video.sender.replaceTrack(track)));
+    }
+    async receive(m, gen) {
+        if (m.type === "ready") {
+            this.send({ type: "room.join", groupId: this.state.groupId, requestId: String(gen) });
+            this.lastSeen = Date.now();
+            this.heartbeat = setInterval(() => { if (Date.now() - this.lastSeen > 60000)
+                this.fail("DISCONNECTED");
+            else
+                this.send({ type: "ping" }); }, 20000);
+            return;
+        }
+        if (m.type === "pong")
+            return;
+        if (m.type === "error") {
+            if (m.code === "SCREEN_BUSY") {
+                await this.stopSharing();
+                this.update({ error: "SCREEN_BUSY" });
+                return;
+            }
+            this.fail(m.code);
+            return;
+        }
+        if (m.type === "room.joined") {
+            if (m.requestId !== String(gen))
+                return;
+            clearTimeout(this.timer);
+            this.iceServers = m.iceServers;
+            this.update({ phase: "joined", meetingId: m.meetingId, selfId: m.selfId });
+            return;
+        }
+        if (m.meetingId !== this.state.meetingId || this.state.phase !== "joined")
+            return;
+        if (m.type === "room.state") {
+            const old = new Map(this.state.participants.map(p => [p.id, p]));
+            this.update({ sharingId: m.sharingId ?? undefined, participants: m.participants.map((p) => ({ ...old.get(p.id), ...p, connection: p.id === this.state.selfId ? "connected" : old.get(p.id)?.connection ?? "connecting" })) });
+            for (const [id, l] of this.links)
+                if (!this.state.participants.some(p => p.id === id)) {
+                    this.links.delete(id);
+                    clearTimeout(l.timer);
+                    l.pc.close();
+                }
+            for (const p of this.state.participants)
+                if (p.id !== this.state.selfId)
+                    this.link(p.id, gen);
+            await this.syncScreen();
+            return;
+        }
+        if (!this.state.participants.some(p => p.id === m.peerId) || m.peerId === this.state.selfId)
+            return;
+        const l = this.link(m.peerId, gen), pc = l.pc;
+        if (m.type === "room.offer") {
+            await pc.setLocalDescription(await pc.createOffer());
+            if (gen === this.generation)
+                this.send({ type: "room.sdp", meetingId: this.state.meetingId, peerId: m.peerId, description: pc.localDescription });
+        }
+        else if (m.type === "room.sdp") {
+            await pc.setRemoteDescription(m.description);
+            if (gen !== this.generation)
+                return;
+            for (const c of l.candidates.splice(0))
+                await pc.addIceCandidate(c);
+            if (m.description.type === "offer") {
+                // setRemoteDescription may create the answerer's receiving transceiver;
+                // attach sharing to that negotiated m-line, not an unassociated local one.
+                const negotiated = pc.getTransceivers().find(t => t.mid !== null && t.receiver.track.kind === "video");
+                if (negotiated) {
+                    if (l.video !== negotiated && l.video.mid === null)
+                        l.video.stop();
+                    l.video = negotiated;
+                    l.video.direction = "sendrecv";
+                    await l.video.sender.replaceTrack(this.state.sharingId === this.state.selfId ? this.screen?.getVideoTracks()[0] ?? null : null);
+                }
+                await pc.setLocalDescription(await pc.createAnswer());
+                if (gen === this.generation)
+                    this.send({ type: "room.sdp", meetingId: this.state.meetingId, peerId: m.peerId, description: pc.localDescription });
+            }
+            for (const sender of pc.getSenders()) {
+                const params = sender.getParameters();
+                if (params.encodings?.length) {
+                    for (const encoding of params.encodings)
+                        encoding.maxBitrate = sender === l.video.sender ? 800000 : 64000;
+                    await sender.setParameters(params);
+                }
+            }
+        }
+        else if (m.type === "room.ice") {
+            if (pc.remoteDescription)
+                await pc.addIceCandidate(m.candidate);
+            else if (l.candidates.length < 128)
+                l.candidates.push(m.candidate);
+        }
+    }
+}

package/lib/runtime/presence.d.ts

@@ -0,0 +1,44 @@
+export type PresenceStatus = "online" | "offline" | "unknown";
+export type ChatPresence = {
+    appId: string;
+    profileId: string;
+    status: PresenceStatus;
+    availability: "normal" | "degraded";
+};
+export type PresenceOptions = {
+    appId: string;
+    profileId: string;
+    instanceId?: string;
+    token: () => Promise<string> | string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    onError?: (error: unknown) => void;
+};
+/** One instance is one authenticated client/runtime lease, never a whole profile. */
+export declare class ChatPresenceClient {
+    private options;
+    readonly instanceId: string;
+    private seq;
+    private active;
+    private generation;
+    private beatTimer?;
+    private queryTimer?;
+    private expiryTimer?;
+    private beating;
+    private querying;
+    private profiles;
+    private entries;
+    private handlers;
+    private availability;
+    constructor(options: PresenceOptions);
+    snapshot(): ChatPresence[];
+    watch(handler: (items: ChatPresence[]) => void): () => void;
+    watchProfiles(ids: string[]): void;
+    setAvailability(value: "normal" | "degraded"): void;
+    start(): void;
+    stop(): void;
+    private request;
+    private heartbeat;
+    private query;
+    private emit;
+}

package/lib/runtime/presence.js

@@ -0,0 +1,132 @@
+/** One instance is one authenticated client/runtime lease, never a whole profile. */
+export class ChatPresenceClient {
+    options;
+    instanceId;
+    seq = 0;
+    active = false;
+    generation = 0;
+    beatTimer;
+    queryTimer;
+    expiryTimer;
+    beating = false;
+    querying = false;
+    profiles = [];
+    entries = new Map();
+    handlers = new Set();
+    availability = "normal";
+    constructor(options) {
+        this.options = options;
+        this.instanceId = options.instanceId ?? crypto.randomUUID();
+    }
+    snapshot() {
+        return this.profiles.map(profileId => {
+            const entry = this.entries.get(profileId);
+            return entry && entry.expires > Date.now() ? { appId: entry.appId, profileId, status: entry.status, availability: entry.availability }
+                : { appId: this.options.appId, profileId, status: "unknown", availability: "normal" };
+        });
+    }
+    watch(handler) { this.handlers.add(handler); handler(this.snapshot()); return () => { this.handlers.delete(handler); }; }
+    watchProfiles(ids) {
+        const profiles = [...new Set(ids)].sort().slice(0, 50);
+        if (JSON.stringify(profiles) === JSON.stringify(this.profiles))
+            return;
+        this.profiles = profiles;
+        this.generation++;
+        this.entries.clear();
+        this.emit();
+        if (this.active)
+            void this.query();
+    }
+    setAvailability(value) { this.availability = value; }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.generation++;
+        void this.heartbeat();
+        void this.query();
+        this.beatTimer = setInterval(() => void this.heartbeat(), 20_000);
+        this.queryTimer = setInterval(() => void this.query(), 5_000);
+        this.expiryTimer = setInterval(() => {
+            if ([...this.entries.values()].some(e => e.expires <= Date.now())) {
+                for (const [id, e] of this.entries)
+                    if (e.expires <= Date.now())
+                        this.entries.delete(id);
+                this.emit();
+            }
+        }, 1000);
+    }
+    stop() {
+        const wasActive = this.active;
+        this.active = false;
+        this.generation++;
+        clearInterval(this.beatTimer);
+        clearInterval(this.queryTimer);
+        clearInterval(this.expiryTimer);
+        this.entries.clear();
+        this.emit();
+        // Sequence tombstones prevent an in-flight heartbeat from undoing release.
+        if (wasActive)
+            void this.request("release", { instanceId: this.instanceId, seq: ++this.seq }).catch(e => this.options.onError?.(e));
+    }
+    async request(action, params) {
+        const token = await this.options.token();
+        const response = await (this.options.fetchImpl ?? fetch)(`${(this.options.baseUrl ?? "https://hub.pmate.chat").replace(/\/$/, "")}/api/chat-presence/${action}`, {
+            method: "POST", headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ appId: this.options.appId, profileId: this.options.profileId, ...params }), signal: AbortSignal.timeout(12_000), keepalive: action === "release",
+        });
+        if (!response.ok)
+            throw new Error(`Presence request failed (${response.status})`);
+        const result = await response.json();
+        if (!result.success)
+            throw new Error("Presence unavailable");
+        return result.data;
+    }
+    async heartbeat() {
+        if (!this.active || this.beating)
+            return;
+        this.beating = true;
+        try {
+            await this.request("heartbeat", { instanceId: this.instanceId, seq: ++this.seq, availability: this.availability });
+        }
+        catch (e) {
+            this.options.onError?.(e);
+        }
+        finally {
+            this.beating = false;
+        }
+    }
+    async query() {
+        if (!this.active || !this.profiles.length || this.querying)
+            return;
+        this.querying = true;
+        const generation = this.generation, requested = this.profiles.slice(), started = Date.now();
+        try {
+            const result = await this.request("query", { profileIds: requested });
+            if (!this.active || generation !== this.generation)
+                return;
+            if (!Array.isArray(result?.items))
+                throw new Error("Invalid presence snapshot");
+            const entries = new Map();
+            for (const item of result.items) {
+                if (item.appId !== this.options.appId || !requested.includes(item.profileId) || !["online", "offline", "unknown"].includes(item.status) || !Number.isFinite(item.validForMs) || item.validForMs < 0)
+                    throw new Error("Invalid presence item");
+                entries.set(item.profileId, { ...item, availability: item.availability === "degraded" ? "degraded" : "normal", expires: started + Math.min(item.validForMs, 10_000) });
+            }
+            this.entries = entries;
+            this.emit();
+        }
+        catch (e) {
+            if (generation === this.generation) {
+                this.entries.clear();
+                this.emit();
+            }
+            this.options.onError?.(e);
+        }
+        finally {
+            this.querying = false;
+        }
+    }
+    emit() { const items = this.snapshot(); for (const h of this.handlers)
+        h(items); }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",