@pmate/chat-sdk 0.4.1 → 0.5.1

package/lib/hooks/useMentions.js

@@ -1,10 +1,11 @@
-import { useId, useRef, useState } from "react";
+import { useId, useLayoutEffect, useRef, useState } from "react";
 import { filterMentionCandidates, findMentionQuery, rebaseMentions } from "../mentions/model";
 /** Attach inputProps to a textarea, render MentionMenu with menuProps, and pass
  * getMentions() with the untrimmed value when sending. No business lookup is performed. */
 export function useMentions({ value, onChange, config, disabled = false }) {
     const id = useId();
     const inputRef = useRef(null);
+    const pendingSelection = useRef(null);
     const menuRef = useRef(null);
     const document = useRef({ text: value, mentions: [] });
     const [caret, setCaret] = useState(0);
@@ -17,6 +18,17 @@ export function useMentions({ value, onChange, config, disabled = false }) {
     const query = config && focused && !composing && !disabled && !dismissed ? findMentionQuery(value, caret) : null;
     const candidates = query ? filterMentionCandidates(config.candidates, query.query) : [];
     const index = Math.min(activeIndex, Math.max(0, candidates.length - 1));
+    // Set the caret as soon as the controlled value commits. A later animation
+    // frame can otherwise move it backwards after the user's next keystroke.
+    useLayoutEffect(() => {
+        const pending = pendingSelection.current;
+        if (!pending || pending.text !== value)
+            return;
+        pendingSelection.current = null;
+        inputRef.current?.focus();
+        inputRef.current?.setSelectionRange(pending.position, pending.position);
+        setCaret(pending.position);
+    }, [value]);
     function select(candidate) {
         if (!query)
             return;
@@ -27,13 +39,8 @@ export function useMentions({ value, onChange, config, disabled = false }) {
             mentions: [...rebaseMentions(value, next, mentions), { id: candidate.id, name: candidate.name, start: query.start, end: query.start + insertion.length }].sort((a, b) => a.start - b.start),
         };
         setDismissed(true);
+        pendingSelection.current = { text: next, position: query.start + insertion.length + 1 };
         onChange(next);
-        requestAnimationFrame(() => {
-            const position = query.start + insertion.length + 1;
-            inputRef.current?.focus();
-            inputRef.current?.setSelectionRange(position, position);
-            setCaret(position);
-        });
     }
     function updateSelection(event) {
         inputRef.current = event.currentTarget;

package/lib/runtime/activity.d.ts

@@ -1,5 +1,5 @@
 import { type ChatRuntimeMessage } from "./protocol.js";
-export type ChatActivityState = "thinking" | "searching" | "reading" | "typing" | "idle";
+export type ChatActivityState = "working" | "typing" | "idle";
 export type ChatActivityBody = {
     kind: "activity";
     appId: string;
@@ -7,6 +7,9 @@ export type ChatActivityBody = {
     activityId: string;
     seq: number;
     state: ChatActivityState;
+    /** Open operation identifier, e.g. thinking, search, read. Unknown phases remain displayable. */
+    phase?: string;
+    replyTo?: string;
     ttlMs: number;
     /** Short public operation label, never private model reasoning. */
     detail?: string;
@@ -22,6 +25,7 @@ export type ActivityTarget = {
     to: string;
     threadKind?: "dm" | "group";
     recipients?: string[];
+    replyTo?: string;
 };
 export declare const ACTIVITY_TTL_MS = 15000;
 export declare function createActivityMessage(input: ActivityTarget & {
@@ -30,6 +34,7 @@ export declare function createActivityMessage(input: ActivityTarget & {
     activityId: string;
     seq: number;
     state: ChatActivityState;
+    phase?: string;
     detail?: string;
 }): ChatRuntimeMessage;
 export declare function parseChatActivity(message: ChatRuntimeMessage, appId: string, profileId: string, now?: number): ChatActivity | null;
@@ -45,23 +50,28 @@ export declare class ChatActivityStore {
     clear(): void;
     private emit;
 }
+export type ChatActivityUpdate = {
+    state: Exclude<ChatActivityState, "idle">;
+    phase?: string;
+    detail?: string;
+};
 /** Coalesced, serialized, best-effort progress; transport failures never reject the chat task. */
 export declare class ChatActivityPublisher {
     private readonly send;
     private readonly onError;
     private seq;
     private stopped;
-    private state;
-    private detail;
+    private current;
     private pending;
     private sending;
     private timer;
     constructor(send: (value: {
         state: ChatActivityState;
+        phase?: string;
         detail?: string;
         seq: number;
     }) => Promise<unknown>, onError?: (error: unknown) => void);
-    update(state: Exclude<ChatActivityState, "idle">, detail?: string): void;
+    update(value: ChatActivityUpdate): void;
     stop(): Promise<void>;
     private enqueue;
     private flush;

package/lib/runtime/activity.js

@@ -3,6 +3,8 @@ import { dmThreadId, groupThreadId } from "./thread.js";
 export const ACTIVITY_TTL_MS = 15_000;
 export function createActivityMessage(input) {
     const body = { kind: "activity", appId: input.appId, threadKind: input.threadKind ?? "dm", activityId: input.activityId, seq: input.seq, state: input.state, ttlMs: ACTIVITY_TTL_MS,
+        ...(input.phase ? { phase: input.phase } : {}),
+        ...(input.replyTo ? { replyTo: input.replyTo } : {}),
         ...(input.detail ? { detail: Array.from(input.detail).slice(0, 120).join("") } : {}) };
     const message = createRuntimeMsg(input.from, input.to, ChatMsgOp.CHAT, body);
     if (body.threadKind === "group")
@@ -16,7 +18,9 @@ export function parseChatActivity(message, appId, profileId, now = Date.now()) {
         || (body.threadKind === "dm" ? message.to !== profileId : !message.recipients?.includes(profileId))
         || typeof body.activityId !== "string" || !body.activityId || body.activityId.length > 128
         || !Number.isSafeInteger(body.seq) || body.seq < 0
-        || !["thinking", "searching", "reading", "typing", "idle"].includes(body.state ?? "")
+        || !["working", "typing", "idle"].includes(body.state ?? "")
+        || (body.phase !== undefined && (typeof body.phase !== "string" || !/^[a-z][a-z0-9._-]{0,63}$/.test(body.phase)))
+        || (body.replyTo !== undefined && (typeof body.replyTo !== "string" || !body.replyTo || body.replyTo.length > 128))
         || !Number.isFinite(body.ttlMs) || body.ttlMs < 1000 || body.ttlMs > ACTIVITY_TTL_MS
         || !Number.isFinite(message.t) || message.t > now + ACTIVITY_TTL_MS || message.t + body.ttlMs <= now
         || (body.detail !== undefined && (typeof body.detail !== "string" || Array.from(body.detail).length > 120)))
@@ -52,7 +56,7 @@ export class ChatActivityStore {
             return;
         let changed = false;
         for (const [key, record] of this.records) {
-            if (record.from === message.from && record.to === message.to && record.threadKind === body.threadKind && record.updatedAt <= message.t && record.state !== "idle") {
+            if (record.from === message.from && record.to === message.to && record.threadKind === body.threadKind && (record.replyTo && body.content?.replyTo ? record.replyTo === body.content.replyTo : record.updatedAt <= message.t) && record.state !== "idle") {
                 this.records.set(key, { ...record, state: "idle" });
                 changed = true;
             }
@@ -76,33 +80,31 @@ export class ChatActivityPublisher {
     onError;
     seq = 0;
     stopped = false;
-    state = "thinking";
-    detail;
+    current = { state: "working" };
     pending;
     sending;
     timer;
     constructor(send, onError = () => { }) {
         this.send = send;
         this.onError = onError;
-        this.timer = setInterval(() => this.enqueue(this.state, this.detail), 5000);
+        this.timer = setInterval(() => this.enqueue(this.current), 5000);
     }
-    update(state, detail) {
+    update(value) {
         if (this.stopped)
             return;
-        this.state = state;
-        this.detail = detail;
-        this.enqueue(state, detail);
+        this.current = value;
+        this.enqueue(value);
     }
     async stop() {
         if (!this.stopped) {
             this.stopped = true;
             clearInterval(this.timer);
-            this.enqueue("idle");
+            this.enqueue({ state: "idle" });
         }
         await this.sending;
     }
-    enqueue(state, detail) {
-        this.pending = { state, detail };
+    enqueue(value) {
+        this.pending = value;
         if (!this.sending)
             this.sending = this.flush().finally(() => { this.sending = undefined; });
     }

package/lib/runtime/chatClient.d.ts

@@ -1,4 +1,4 @@
-import { ChatActivityPublisher, type ActivityTarget, type ChatActivity, type ChatActivityState } from "./activity.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";
 import { type PmateBotKeyFile } from "./botKey.js";
@@ -34,9 +34,10 @@ export declare class ChatClient {
         activityId: string;
         seq: number;
         state: ChatActivityState;
+        phase?: string;
         detail?: string;
     }): Promise<ChatRuntimeMessage>;
-    startActivity(target: ActivityTarget, state?: Exclude<ChatActivityState, "idle">): ChatActivityPublisher;
+    startActivity(target: ActivityTarget, initial?: ChatActivityUpdate): ChatActivityPublisher;
     requestFriend(input: {
         to: string;
         message?: string;

package/lib/runtime/chatClient.js

@@ -74,13 +74,13 @@ export class ChatClient {
         await this.sendAndWaitForAck(message);
         return message;
     }
-    startActivity(target, state = "typing") {
+    startActivity(target, initial = { state: "typing" }) {
         const activityId = createRuntimeMsg(this.profileId(), target.to, ChatMsgOp.CHAT, null).hash;
         const publisher = new ChatActivityPublisher(value => this.sendActivity({ ...target, activityId, ...value }), error => this.options.onActivityError?.(error));
         this.publishers.add(publisher);
         const stop = publisher.stop.bind(publisher);
         publisher.stop = async () => { await stop(); this.publishers.delete(publisher); };
-        publisher.update(state);
+        publisher.update(initial);
         return publisher;
     }
     async requestFriend(input) {

package/package.json

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