@astropods/messaging 0.0.1 → 0.0.2

package/dist/messaging-client.d.ts

@@ -135,6 +135,20 @@ export interface ConversationRequest {
     agentConfig?: AgentConfig;
     agentResponse?: AgentResponse;
 }
+export interface ReconnectOptions {
+    /** Maximum number of reconnect attempts. Default: Infinity */
+    maxRetries?: number;
+    /** Initial delay before first retry in ms. Default: 500 */
+    initialDelayMs?: number;
+    /** Maximum delay between retries in ms. Default: 30_000 */
+    maxDelayMs?: number;
+    /** Apply full jitter to backoff delay. Default: true */
+    jitter?: boolean;
+    /** Maximum number of writes to queue during reconnect. Default: 1000 */
+    maxBufferSize?: number;
+    /** gRPC status codes that trigger a reconnect attempt. Default: UNAVAILABLE, DEADLINE_EXCEEDED, INTERNAL, RESOURCE_EXHAUSTED */
+    retryableStatusCodes?: number[];
+}
 /**
  * MessagingClient provides a TypeScript interface to the Astro Messaging gRPC service
  */
@@ -149,9 +163,14 @@ export declare class MessagingClient extends EventEmitter {
      */
     connect(): Promise<void>;
     /**
-     * Create a bidirectional conversation stream
+     * Connect with automatic retry on failure (exponential backoff).
+     * Emits 'reconnecting' before each retry and 'reconnected' on success after failures.
+     */
+    connectWithRetry(options?: ReconnectOptions): Promise<void>;
+    /**
+     * Create a bidirectional conversation stream with optional reconnect support
      */
-    createConversationStream(): ConversationStream;
+    createConversationStream(options?: ReconnectOptions): ConversationStream;
     /**
      * Process a single message (server-side streaming)
      */
@@ -176,11 +195,31 @@ export declare class MessagingClient extends EventEmitter {
     close(): void;
 }
 /**
- * ConversationStream wraps a bidirectional gRPC stream
+ * ConversationStream wraps a bidirectional gRPC stream with automatic reconnection.
+ *
+ * Events:
+ *   - 'response'     — AgentResponse received from server
+ *   - 'reconnecting' — { attempt, reason, delayMs } — before each retry delay
+ *   - 'reconnected'  — { attempt } — after a successful stream recreation
+ *   - 'error'        — non-retryable error OR max retries exceeded
+ *   - 'end'          — only on intentional close(), not on unexpected stream drop
  */
 export declare class ConversationStream extends EventEmitter {
+    private streamFactory;
     private stream;
-    constructor(stream: any);
+    private writeBuffer;
+    private reconnecting;
+    private closed;
+    private retryCount;
+    private readonly opts;
+    constructor(streamFactory: () => any, options?: ReconnectOptions);
+    private attachHandlers;
+    private isRetryable;
+    private calculateDelay;
+    private scheduleReconnect;
+    private doReconnect;
+    private flushBuffer;
+    private write;
     /**
      * Send a message through the stream
      */
@@ -206,7 +245,7 @@ export declare class ConversationStream extends EventEmitter {
      */
     sendStatusUpdate(conversationId: string, status: StatusUpdate): void;
     /**
-     * End the stream
+     * End the stream intentionally. Emits 'end' and prevents any further reconnects.
      */
     end(): void;
 }

package/dist/messaging-client.js

@@ -38,6 +38,18 @@ const grpc = __importStar(require("@grpc/grpc-js"));
 const protoLoader = __importStar(require("@grpc/proto-loader"));
 const path_1 = require("path");
 const events_1 = require("events");
+// gRPC status codes: DEADLINE_EXCEEDED=4, INTERNAL=13, UNAVAILABLE=14, RESOURCE_EXHAUSTED=8
+const DEFAULT_RETRYABLE_STATUS_CODES = [4, 8, 13, 14];
+function resolveReconnectOptions(options) {
+    return {
+        maxRetries: options.maxRetries ?? Infinity,
+        initialDelayMs: options.initialDelayMs ?? 500,
+        maxDelayMs: options.maxDelayMs ?? 30000,
+        jitter: options.jitter ?? true,
+        maxBufferSize: options.maxBufferSize ?? 1000,
+        retryableStatusCodes: options.retryableStatusCodes ?? DEFAULT_RETRYABLE_STATUS_CODES,
+    };
+}
 /**
  * MessagingClient provides a TypeScript interface to the Astro Messaging gRPC service
  */
@@ -45,6 +57,7 @@ class MessagingClient extends events_1.EventEmitter {
     constructor(serverAddress) {
         super();
         this.serverAddress = serverAddress;
+        this.conversationStream = null;
         this.isConnected = false;
     }
     /**
@@ -67,14 +80,42 @@ class MessagingClient extends events_1.EventEmitter {
         this.emit('connected');
     }
     /**
-     * Create a bidirectional conversation stream
+     * Connect with automatic retry on failure (exponential backoff).
+     * Emits 'reconnecting' before each retry and 'reconnected' on success after failures.
+     */
+    async connectWithRetry(options = {}) {
+        const opts = resolveReconnectOptions(options);
+        let retryCount = 0;
+        while (true) {
+            try {
+                await this.connect();
+                if (retryCount > 0) {
+                    this.emit('reconnected', { attempt: retryCount });
+                }
+                return;
+            }
+            catch (err) {
+                if (retryCount >= opts.maxRetries) {
+                    throw err;
+                }
+                const base = Math.min(opts.initialDelayMs * Math.pow(2, retryCount), opts.maxDelayMs);
+                const delayMs = opts.jitter ? base * (0.5 + Math.random() * 0.5) : base;
+                this.emit('reconnecting', { attempt: retryCount + 1, reason: err, delayMs });
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+                retryCount++;
+            }
+        }
+    }
+    /**
+     * Create a bidirectional conversation stream with optional reconnect support
      */
-    createConversationStream() {
+    createConversationStream(options) {
         if (!this.isConnected) {
             throw new Error('Client not connected. Call connect() first.');
         }
-        this.conversationStream = this.client.ProcessConversation();
-        return new ConversationStream(this.conversationStream);
+        const factory = () => this.client.ProcessConversation();
+        this.conversationStream = new ConversationStream(factory, options);
+        return this.conversationStream;
     }
     /**
      * Process a single message (server-side streaming)
@@ -169,57 +210,122 @@ class MessagingClient extends events_1.EventEmitter {
 }
 exports.MessagingClient = MessagingClient;
 /**
- * ConversationStream wraps a bidirectional gRPC stream
+ * ConversationStream wraps a bidirectional gRPC stream with automatic reconnection.
+ *
+ * Events:
+ *   - 'response'     — AgentResponse received from server
+ *   - 'reconnecting' — { attempt, reason, delayMs } — before each retry delay
+ *   - 'reconnected'  — { attempt } — after a successful stream recreation
+ *   - 'error'        — non-retryable error OR max retries exceeded
+ *   - 'end'          — only on intentional close(), not on unexpected stream drop
  */
 class ConversationStream extends events_1.EventEmitter {
-    constructor(stream) {
+    constructor(streamFactory, options = {}) {
         super();
-        this.stream = stream;
-        this.stream.on('data', (response) => {
+        this.streamFactory = streamFactory;
+        this.writeBuffer = [];
+        this.reconnecting = false;
+        this.closed = false;
+        this.retryCount = 0;
+        this.opts = resolveReconnectOptions(options);
+        this.stream = this.streamFactory();
+        this.attachHandlers(this.stream);
+    }
+    attachHandlers(stream) {
+        stream.on('data', (response) => {
+            this.retryCount = 0;
             this.emit('response', response);
         });
-        this.stream.on('end', () => {
-            this.emit('end');
+        stream.on('error', (error) => {
+            if (!this.closed && this.isRetryable(error)) {
+                this.scheduleReconnect(error);
+            }
+            else {
+                this.emit('error', error);
+            }
         });
-        this.stream.on('error', (error) => {
-            this.emit('error', error);
+        stream.on('end', () => {
+            if (!this.closed) {
+                this.scheduleReconnect(new Error('Stream ended unexpectedly'));
+            }
+            // If closed, 'end' was already emitted by end() — do nothing
         });
     }
+    isRetryable(error) {
+        return this.opts.retryableStatusCodes.includes(error.code);
+    }
+    calculateDelay() {
+        const base = Math.min(this.opts.initialDelayMs * Math.pow(2, this.retryCount), this.opts.maxDelayMs);
+        return this.opts.jitter ? base * (0.5 + Math.random() * 0.5) : base;
+    }
+    scheduleReconnect(reason) {
+        if (this.reconnecting || this.closed)
+            return;
+        if (this.retryCount >= this.opts.maxRetries) {
+            this.emit('error', new Error(`Max reconnection attempts (${this.opts.maxRetries}) exceeded`));
+            return;
+        }
+        const delayMs = this.calculateDelay();
+        this.reconnecting = true;
+        this.emit('reconnecting', { attempt: this.retryCount + 1, reason, delayMs });
+        setTimeout(() => this.doReconnect(), delayMs);
+    }
+    doReconnect() {
+        if (this.closed)
+            return;
+        this.retryCount++;
+        try {
+            this.stream = this.streamFactory();
+            this.attachHandlers(this.stream);
+            this.reconnecting = false;
+            this.emit('reconnected', { attempt: this.retryCount });
+            this.flushBuffer();
+        }
+        catch (err) {
+            this.reconnecting = false;
+            this.scheduleReconnect(err);
+        }
+    }
+    flushBuffer() {
+        const toFlush = this.writeBuffer.splice(0);
+        for (const request of toFlush) {
+            this.stream.write(request);
+        }
+    }
+    write(request) {
+        if (this.reconnecting || this.closed) {
+            if (this.writeBuffer.length >= this.opts.maxBufferSize) {
+                this.writeBuffer.shift(); // drop oldest
+            }
+            this.writeBuffer.push(request);
+        }
+        else {
+            this.stream.write(request);
+        }
+    }
     /**
      * Send a message through the stream
      */
     sendMessage(message) {
-        const request = {
-            message,
-        };
-        this.stream.write(request);
+        this.write({ message });
     }
     /**
      * Send platform feedback through the stream
      */
     sendFeedback(feedback) {
-        const request = {
-            feedback,
-        };
-        this.stream.write(request);
+        this.write({ feedback });
     }
     /**
      * Send agent configuration through the stream
      */
     sendAgentConfig(config) {
-        const request = {
-            agentConfig: config,
-        };
-        this.stream.write(request);
+        this.write({ agentConfig: config });
     }
     /**
      * Send a typed AgentResponse through the stream
      */
     sendAgentResponse(response) {
-        const request = {
-            agentResponse: response,
-        };
-        this.stream.write(request);
+        this.write({ agentResponse: response });
     }
     /**
      * Send a content chunk (START/DELTA/END) for a conversation
@@ -240,10 +346,13 @@ class ConversationStream extends events_1.EventEmitter {
         });
     }
     /**
-     * End the stream
+     * End the stream intentionally. Emits 'end' and prevents any further reconnects.
      */
     end() {
+        this.closed = true;
+        this.writeBuffer = [];
         this.stream.end();
+        this.emit('end');
     }
 }
 exports.ConversationStream = ConversationStream;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astropods/messaging",
   "license": "Apache-2.0",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "TypeScript SDK for Astro Messaging",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,7 @@
     "dist"
   ],
   "scripts": {
-    "postinstall": "ln -sf ../../proto proto",
+    "postinstall": "rm -rf proto && ln -sf ../../proto proto",
     "build": "tsc && cp -r ../../proto dist/proto",
     "watch": "tsc --watch",
     "test": "bun test",