@inline-chat/realtime-sdk 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { InlineSdkClient } from "./sdk/inline-sdk-client.js";
-export type { InlineSdkClientOptions, InlineSdkSendMessageMedia, InlineSdkSendMessageParams, InlineSdkState, InlineSdkStateStore, InlineSdkUploadFileParams, InlineSdkUploadFileResult, InlineSdkUploadFileType, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
+export type { InlineSdkClientOptions, InlineSdkGetMessagesParams, InlineSdkSendMessageMedia, InlineSdkSendMessageParams, InlineSdkState, InlineSdkStateStore, InlineSdkUploadFileParams, InlineSdkUploadFileResult, InlineSdkUploadFileType, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
 export type { InlineSdkLogger } from "./sdk/logger.js";
 export { JsonFileStateStore } from "./state/json-file-state-store.js";
 export { serializeStateV1, deserializeStateV1 } from "./state/serde.js";

package/dist/realtime/protocol-client.d.ts

@@ -9,6 +9,7 @@ export type ProtocolClientOptions = {
     transport: Transport;
     getConnectionInit: () => ConnectionInit | null;
     logger?: InlineSdkLogger;
+    defaultRpcTimeoutMs?: number | null;
 };
 export declare class ProtocolClient {
     readonly events: AsyncChannel<ClientEvent>;
@@ -17,7 +18,8 @@ export declare class ProtocolClient {
     state: ClientState;
     private readonly log;
     private readonly getConnectionInit;
-    private rpcContinuations;
+    private readonly defaultRpcTimeoutMs;
+    private pendingRpcRequests;
     private seq;
     private lastTimestamp;
     private sequence;
@@ -35,7 +37,7 @@ export declare class ProtocolClient {
     }): Promise<void>;
     sendRpc(method: Method, input?: RpcCall["input"]): Promise<bigint>;
     callRpc(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     private startListeners;
     private handleTransportMessage;
@@ -53,10 +55,14 @@ export declare class ProtocolClient {
     private generateId;
     private currentTimestamp;
     private completeRpcResult;
+    private ensureOpenForRpc;
     private completeRpcError;
-    private failRpcContinuation;
-    private getAndRemoveRpcContinuation;
-    private cancelAllRpcContinuations;
+    private failPendingRpcRequest;
+    private getAndRemovePendingRpcRequest;
+    private cancelAllPendingRpcRequests;
+    private resolveRpcTimeoutMs;
+    private resendPendingRpcRequests;
+    private trySendPendingRpcRequest;
 }
 export declare class ProtocolClientError extends Error {
     constructor(code: "not-authorized" | "not-connected" | "rpc-error" | "stopped" | "timeout", details?: {

package/dist/realtime/protocol-client.js

@@ -2,6 +2,7 @@ import { ClientMessage, ServerProtocolMessage } from "@inline-chat/protocol/core
 import { AsyncChannel } from "../utils/async-channel.js";
 import { PingPongService } from "./ping-pong.js";
 const emptyRpcInput = { oneofKind: undefined };
+const defaultRpcTimeoutMs = 30_000;
 export class ProtocolClient {
     events = new AsyncChannel();
     transport;
@@ -9,7 +10,8 @@ export class ProtocolClient {
     state = "connecting";
     log;
     getConnectionInit;
-    rpcContinuations = new Map();
+    defaultRpcTimeoutMs;
+    pendingRpcRequests = new Map();
     seq = 0;
     lastTimestamp = 0;
     sequence = 0;
@@ -22,6 +24,7 @@ export class ProtocolClient {
         this.transport = options.transport;
         this.log = options.logger ?? {};
         this.getConnectionInit = options.getConnectionInit;
+        this.defaultRpcTimeoutMs = normalizeRpcTimeoutMs(options.defaultRpcTimeoutMs, defaultRpcTimeoutMs);
         this.pingPong = new PingPongService({ logger: this.log });
         this.pingPong.configure(this);
         this.startListeners();
@@ -48,6 +51,7 @@ export class ProtocolClient {
         await this.transport.reconnect({ skipDelay: options?.skipDelay });
     }
     async sendRpc(method, input = emptyRpcInput) {
+        this.ensureOpenForRpc();
         const message = this.wrapMessage({
             oneofKind: "rpcCall",
             rpcCall: { method, input },
@@ -61,17 +65,20 @@ export class ProtocolClient {
             rpcCall: { method, input },
         });
         return await new Promise((resolve, reject) => {
-            const continuation = { resolve, reject };
-            this.rpcContinuations.set(message.id, continuation);
-            void this.transport.send(message).catch((error) => {
-                this.failRpcContinuation(message.id, error instanceof Error ? error : new Error("send-failed"));
-            });
-            const timeoutMs = options?.timeoutMs ?? 15_000;
-            if (timeoutMs > 0) {
-                continuation.timeout = setTimeout(() => {
-                    this.failRpcContinuation(message.id, new ProtocolClientError("timeout"));
-                }, timeoutMs);
+            const pending = {
+                message,
+                resolve,
+                reject,
+                timeoutMs: this.resolveRpcTimeoutMs(options?.timeoutMs),
+                sending: false,
+            };
+            this.pendingRpcRequests.set(message.id, pending);
+            if (pending.timeoutMs !== null) {
+                pending.timeout = setTimeout(() => {
+                    this.failPendingRpcRequest(message.id, new ProtocolClientError("timeout"));
+                }, pending.timeoutMs);
             }
+            this.trySendPendingRpcRequest(message.id);
         });
     }
     async startListeners() {
@@ -168,6 +175,7 @@ export class ProtocolClient {
         }
         this.connectionAttemptNo = 0;
         this.pingPong.start();
+        this.resendPendingRpcRequests();
     }
     async connecting() {
         this.state = "connecting";
@@ -176,7 +184,7 @@ export class ProtocolClient {
     async reset() {
         this.pingPong.stop();
         this.stopAuthenticationTimeout();
-        this.cancelAllRpcContinuations(new ProtocolClientError("stopped"));
+        this.cancelAllPendingRpcRequests(new ProtocolClientError("stopped"));
         this.state = "connecting";
     }
     startAuthenticationTimeout() {
@@ -195,8 +203,8 @@ export class ProtocolClient {
     }
     handleClientFailure() {
         this.pingPong.stop();
-        this.cancelAllRpcContinuations(new ProtocolClientError("not-connected"));
         this.stopAuthenticationTimeout();
+        this.state = "connecting";
         if (this.reconnectionTimer) {
             clearTimeout(this.reconnectionTimer);
         }
@@ -239,36 +247,80 @@ export class ProtocolClient {
         return Math.floor(Date.now() / 1000) - this.epochSeconds;
     }
     completeRpcResult(msgId, rpcResult) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.resolve(rpcResult);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.resolve(rpcResult);
+    }
+    ensureOpenForRpc() {
+        if (this.state !== "open") {
+            throw new ProtocolClientError("not-connected");
+        }
     }
     completeRpcError(msgId, rpcError) {
         const error = new ProtocolClientError("rpc-error", { code: rpcError.code, message: rpcError.message });
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    failRpcContinuation(msgId, error) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+    failPendingRpcRequest(msgId, error) {
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    getAndRemoveRpcContinuation(msgId) {
-        const continuation = this.rpcContinuations.get(msgId);
-        if (!continuation)
+    getAndRemovePendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
             return null;
-        if (continuation.timeout)
-            clearTimeout(continuation.timeout);
-        this.rpcContinuations.delete(msgId);
-        return continuation;
-    }
-    cancelAllRpcContinuations(error) {
-        for (const continuation of this.rpcContinuations.values()) {
-            continuation.reject(error);
-            if (continuation.timeout)
-                clearTimeout(continuation.timeout);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        this.pendingRpcRequests.delete(msgId);
+        return pending;
+    }
+    cancelAllPendingRpcRequests(error) {
+        for (const pending of this.pendingRpcRequests.values()) {
+            pending.reject(error);
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+        }
+        this.pendingRpcRequests.clear();
+    }
+    resolveRpcTimeoutMs(timeoutMs) {
+        return normalizeRpcTimeoutMs(timeoutMs, this.defaultRpcTimeoutMs);
+    }
+    resendPendingRpcRequests() {
+        for (const msgId of this.pendingRpcRequests.keys()) {
+            this.trySendPendingRpcRequest(msgId);
         }
-        this.rpcContinuations.clear();
+    }
+    trySendPendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
+            return;
+        if (this.state !== "open")
+            return;
+        if (pending.sending)
+            return;
+        pending.sending = true;
+        void this.transport
+            .send(pending.message)
+            .catch((error) => {
+            this.log.warn?.("Failed to send RPC request; waiting for reconnect", error);
+            this.handleClientFailure();
+        })
+            .finally(() => {
+            pending.sending = false;
+        });
     }
 }
+const normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
+    const resolved = timeoutMs === undefined ? fallback : timeoutMs;
+    if (resolved == null)
+        return null;
+    if (resolved === Number.POSITIVE_INFINITY)
+        return null;
+    if (!Number.isFinite(resolved))
+        return null;
+    if (resolved <= 0)
+        return null;
+    return Math.floor(resolved);
+};
 export class ProtocolClientError extends Error {
     constructor(code, details) {
         super(details?.message ?? code);

package/dist/sdk/inline-sdk-client.d.ts

@@ -1,6 +1,6 @@
-import { Method, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
+import { Method, type Message, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
 import { type InlineIdLike } from "../ids.js";
-import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkSendMessageParams, InlineSdkState, InlineSdkUploadFileParams, InlineSdkUploadFileResult, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
+import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkGetMessagesParams, InlineSdkSendMessageParams, InlineSdkState, InlineSdkUploadFileParams, InlineSdkUploadFileResult, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
 export declare class InlineSdkClient {
     private readonly options;
     private readonly log;
@@ -33,6 +33,9 @@ export declare class InlineSdkClient {
         peer?: Peer;
         title: string;
     }>;
+    getMessages(params: InlineSdkGetMessagesParams): Promise<{
+        messages: Message[];
+    }>;
     sendMessage(params: InlineSdkSendMessageParams): Promise<{
         messageId: bigint | null;
     }>;
@@ -42,13 +45,13 @@ export declare class InlineSdkClient {
         typing: boolean;
     }): Promise<void>;
     invokeRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invokeUncheckedRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invoke<M extends MappedMethod>(method: M, input: RpcInputForMethod<M>, options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResultForMethod<M>>;
     private assertMethodInputMatch;
     private assertMethodResultMatch;

package/dist/sdk/inline-sdk-client.js

@@ -1,4 +1,4 @@
-import { GetChatInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
+import { GetChatInput, GetMessagesInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
 import { asInlineId } from "../ids.js";
 import { AsyncChannel } from "../utils/async-channel.js";
 import { ProtocolClient } from "../realtime/protocol-client.js";
@@ -53,6 +53,7 @@ export class InlineSdkClient {
                 clientVersion: getSdkVersion(),
             }),
             logger: options.logger,
+            defaultRpcTimeoutMs: options.rpcTimeoutMs,
         });
         void this.startListeners();
     }
@@ -146,6 +147,18 @@ export class InlineSdkClient {
             throw new Error("getChat: missing chat");
         return { chatId: chat.id, peer: chat.peerId, title: chat.title };
     }
+    async getMessages(params) {
+        const peerId = this.inputPeerFromTarget(params, "getMessages");
+        const messageIds = params.messageIds.map((messageId, index) => asInlineId(messageId, `messageIds[${index}]`));
+        const result = await this.invoke(Method.GET_MESSAGES, {
+            oneofKind: "getMessages",
+            getMessages: GetMessagesInput.create({
+                peerId,
+                messageIds,
+            }),
+        });
+        return { messages: result.getMessages.messages };
+    }
     async sendMessage(params) {
         if (params.entities != null && params.parseMarkdown != null) {
             throw new Error("sendMessage: provide either `entities` or `parseMarkdown`, not both");

package/dist/sdk/types.d.ts

@@ -6,6 +6,7 @@ import type { Transport } from "../realtime/transport.js";
 export type InlineSdkClientOptions = {
     baseUrl?: string;
     token: string;
+    rpcTimeoutMs?: number | null;
     logger?: InlineSdkLogger;
     state?: InlineSdkStateStore;
     transport?: Transport;
@@ -40,6 +41,15 @@ export type InlineSdkSendMessageParams = {
     sendMode?: "silent";
     entities?: MessageEntities;
 };
+export type InlineSdkGetMessagesParams = {
+    chatId: InlineIdLike;
+    userId?: never;
+    messageIds: InlineIdLike[];
+} | {
+    userId: InlineIdLike;
+    chatId?: never;
+    messageIds: InlineIdLike[];
+};
 export type InlineSdkBinaryInput = Blob | Uint8Array | ArrayBuffer | SharedArrayBuffer;
 export type InlineSdkUploadFileType = "photo" | "video" | "document";
 export type InlineSdkUploadFileParams = {
@@ -151,6 +161,9 @@ export declare const rpcInputKindByMethod: {
     readonly 33: "listBots";
     readonly 34: "revealBotToken";
     readonly 35: "moveThread";
+    readonly 36: "rotateBotToken";
+    readonly 37: "updateBotProfile";
+    readonly 38: "getMessages";
 };
 export declare const rpcResultKindByMethod: {
     readonly 0: undefined;
@@ -189,6 +202,9 @@ export declare const rpcResultKindByMethod: {
     readonly 33: "listBots";
     readonly 34: "revealBotToken";
     readonly 35: "moveThread";
+    readonly 36: "rotateBotToken";
+    readonly 37: "updateBotProfile";
+    readonly 38: "getMessages";
 };
 type RpcInputKindByMethod = typeof rpcInputKindByMethod;
 type RpcResultKindByMethod = typeof rpcResultKindByMethod;

package/dist/sdk/types.js

@@ -35,6 +35,9 @@ export const rpcInputKindByMethod = {
     33: "listBots",
     34: "revealBotToken",
     35: "moveThread",
+    36: "rotateBotToken",
+    37: "updateBotProfile",
+    38: "getMessages",
 };
 export const rpcResultKindByMethod = {
     0: undefined, // UNSPECIFIED
@@ -73,4 +76,7 @@ export const rpcResultKindByMethod = {
     33: "listBots",
     34: "revealBotToken",
     35: "moveThread",
+    36: "rotateBotToken",
+    37: "updateBotProfile",
+    38: "getMessages",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/realtime-sdk",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "type": "module",
   "files": [
@@ -20,7 +20,7 @@
     "test": "vitest run --coverage"
   },
   "dependencies": {
-    "@inline-chat/protocol": "^0.0.1",
+    "@inline-chat/protocol": "^0.0.2",
     "ws": "^8.18.3"
   },
   "devDependencies": {