@pmate/chat-sdk 0.4.0 → 0.5.0

package/lib/index.d.ts

@@ -31,3 +31,4 @@ export * from "./voice/Recorder";
 export * from "./mentions/model";
 export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
+export * from "./runtime/activity";

package/lib/index.js

@@ -31,3 +31,4 @@ export * from "./voice/Recorder";
 export * from "./mentions/model";
 export * from "./hooks/useMentions";
 export * from "./components/MentionMenu";
+export * from "./runtime/activity";

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; });
     }
@@ -114,7 +116,10 @@ export class ChatActivityPublisher {
                 await this.send({ ...current, seq: this.seq++ });
             }
             catch (error) {
-                this.onError(error);
+                try {
+                    this.onError(error);
+                }
+                catch { /* Error reporting must not break progress cleanup. */ }
             }
         }
     }

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

@@ -42,8 +42,11 @@ export class ChatClient {
         this.client.on(ChatRealtimeEvents.Message, (message) => {
             this.handleIncoming(message);
         });
-        this.client.on(ChatRealtimeEvents.Connected, (connected) => { if (!connected)
-            this.activities.clear(); });
+        this.client.on(ChatRealtimeEvents.Connected, (connected) => { if (!connected) {
+            for (const publisher of this.publishers)
+                void publisher.stop();
+            this.activities.clear();
+        } });
         await this.waitUntilConnected();
         await this.sendAuth();
         return this;
@@ -71,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.0",
+  "version": "0.5.0",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",