@mochabug/adapt-web 0.0.41 → 0.0.45

package/dist/cjs/genproto/mochabugapis/adapt/graph/vertex_config_pb.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright 2023, mochabug AB
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexConfigMetadataSchema = exports.file_mochabugapis_adapt_graph_vertex_config = void 0;
+const codegenv1_1 = require("@bufbuild/protobuf/codegenv1");
+const validate_pb_1 = require("../../../buf/validate/validate_pb");
+const exchange_pb_1 = require("./exchange_pb");
+const receiver_pb_1 = require("./receiver_pb");
+const transmitter_pb_1 = require("./transmitter_pb");
+/**
+ * Describes the file mochabugapis/adapt/graph/vertex_config.proto.
+ */
+exports.file_mochabugapis_adapt_graph_vertex_config = (0, codegenv1_1.fileDesc)("Cixtb2NoYWJ1Z2FwaXMvYWRhcHQvZ3JhcGgvdmVydGV4X2NvbmZpZy5wcm90bxIYbW9jaGFidWdhcGlzLmFkYXB0LmdyYXBoIrkGChRWZXJ0ZXhDb25maWdNZXRhZGF0YRIQCghjb21wbGV0ZRgBIAEoCBKwAQoJcmVjZWl2ZXJzGAIgAygLMiIubW9jaGFidWdhcGlzLmFkYXB0LmdyYXBoLlJlY2VpdmVyQnm6SHa6AWwKFnJlY2VpdmVyc191bmlxdWVfbmFtZXMSJkVhY2ggcmVjZWl2ZXIgbXVzdCBoYXZlIGEgdW5pcXVlIG5hbWUuGip0aGlzLm1hcChyZWNlaXZlciwgcmVjZWl2ZXIubmFtZSkudW5pcXVlKCmSAQQIARAyEsIBCgx0cmFuc21pdHRlcnMYAyADKAsyJS5tb2NoYWJ1Z2FwaXMuYWRhcHQuZ3JhcGguVHJhbnNtaXR0ZXJChAG6SIABugF4Chl0cmFuc21pdHRlcnNfdW5pcXVlX25hbWVzEilFYWNoIHRyYW5zbWl0dGVyIG11c3QgaGF2ZSBhIHVuaXF1ZSBuYW1lLhowdGhpcy5tYXAodHJhbnNtaXR0ZXIsIHRyYW5zbWl0dGVyLm5hbWUpLnVuaXF1ZSgpkgECEDISswEKCnByb2NlZHVyZXMYBCADKAsyIi5tb2NoYWJ1Z2FwaXMuYWRhcHQuZ3JhcGguRXhjaGFuZ2VCe7pIeLoBcAoXcHJvY2VkdXJlc191bmlxdWVfbmFtZXMSJ0VhY2ggcHJvY2VkdXJlIG11c3QgaGF2ZSBhIHVuaXF1ZSBuYW1lLhosdGhpcy5tYXAocHJvY2VkdXJlLCBwcm9jZWR1cmUubmFtZSkudW5pcXVlKCmSAQIQChKkAQoHc3RyZWFtcxgFIAMoCzIiLm1vY2hhYnVnYXBpcy5hZGFwdC5ncmFwaC5FeGNoYW5nZUJvukhsugFkChRzdHJlYW1zX3VuaXF1ZV9uYW1lcxIkRWFjaCBzdHJlYW0gbXVzdCBoYXZlIGEgdW5pcXVlIG5hbWUuGiZ0aGlzLm1hcChzdHJlYW0sIHN0cmVhbS5uYW1lKS51bmlxdWUoKZIBAhAKEigKDWNyb25fc2NoZWR1bGUYBiABKAlCDLpICdgBAnIEEAEYZEgAiAEBQhAKDl9jcm9uX3NjaGVkdWxlYgZwcm90bzM", [validate_pb_1.file_buf_validate_validate, exchange_pb_1.file_mochabugapis_adapt_graph_exchange, receiver_pb_1.file_mochabugapis_adapt_graph_receiver, transmitter_pb_1.file_mochabugapis_adapt_graph_transmitter]);
+/**
+ * Describes the message mochabugapis.adapt.graph.VertexConfigMetadata.
+ * Use `create(VertexConfigMetadataSchema)` to create a new message.
+ */
+exports.VertexConfigMetadataSchema = (0, codegenv1_1.messageDesc)(exports.file_mochabugapis_adapt_graph_vertex_config, 0);
+//# sourceMappingURL=vertex_config_pb.js.map

package/dist/cjs/genproto/mochabugapis/adapt/graph/vertex_config_pb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex_config_pb.js","sourceRoot":"","sources":["../../../../../../src/genproto/mochabugapis/adapt/graph/vertex_config_pb.ts"],"names":[],"mappings":";AAAA,8BAA8B;AAC9B,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;;;AAQjC,4DAAqE;AACrE,mEAA+E;AAE/E,+CAAuE;AAEvE,+CAAuE;AAEvE,qDAA6E;AAG7E;;GAEG;AACU,QAAA,2CAA2C,GACtD,IAAA,oBAAQ,EAAC,6rCAA6rC,EAAE,CAAC,wCAA0B,EAAE,oDAAsC,EAAE,oDAAsC,EAAE,0DAAyC,CAAC,CAAC,CAAC;AA4Gn2C;;;GAGG;AACU,QAAA,0BAA0B,GACrC,IAAA,uBAAW,EAAC,mDAA2C,EAAE,CAAC,CAAC,CAAC"}

package/dist/cjs/index.js

@@ -11,8 +11,26 @@ const protobuf_1 = require("@bufbuild/protobuf");
 const wkt_1 = require("@bufbuild/protobuf/wkt");
 const nats_ws_1 = require("nats.ws");
 const automations_pb_js_1 = require("./genproto/mochabugapis/adapt/automations/v1/automations_pb.js");
+// Constants for JetStream protocol
+const CONSUMER_MSG_NEXT_PREFIX = "$JS.API.CONSUMER.MSG.NEXT.";
+//const ACK_PREFIX = "$JS.ACK.";
+const ACK_POSITIVE = new TextEncoder().encode("+ACK");
+const ACK_NEGATIVE = new TextEncoder().encode("-NAK");
+//const ACK_IN_PROGRESS = new TextEncoder().encode("+WPI");
+//const ACK_TERMINATE = new TextEncoder().encode("+TERM");
+// JetStream Status Codes
+const STATUS_NO_MESSAGES = 404;
+const STATUS_REQUEST_TIMEOUT = 408;
+const STATUS_MAX_ACK_PENDING = 409;
+const STATUS_FLOW_CONTROL = 100;
+// Default configuration
+const DEFAULT_MAX_MESSAGES = 100;
+const DEFAULT_EXPIRES_MS = 30000;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_THRESHOLD_RATIO = 0.5;
 const natsUrl = "wss://adapt-dev.mochabugapis.com:443/pubsub";
 const baseUrl = "https://adapt-dev.mochabugapis.com/v1/automations";
+// REST API functions (unchanged from original)
 async function startSession(req, token) {
     const headers = new Headers({
         "Content-Type": "application/json",
@@ -106,6 +124,7 @@ class RestClientError extends Error {
     }
 }
 exports.RestClientError = RestClientError;
+// Connection states
 var ConnectionState;
 (function (ConnectionState) {
     ConnectionState["DISCONNECTED"] = "disconnected";
@@ -125,15 +144,17 @@ class PubsubClient {
         this.urlHandler = null;
         this.isReconnecting = false;
         this.connectionState = ConnectionState.DISCONNECTED;
+        // Pull consumer state
+        this.pending = 0;
+        this.pulling = false;
+        this.pullTimer = null;
+        this.maxMessages = DEFAULT_MAX_MESSAGES;
+        this.expiresMs = DEFAULT_EXPIRES_MS;
+        this.pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+        this.threshold = DEFAULT_MAX_MESSAGES * DEFAULT_THRESHOLD_RATIO;
+        this.inbox = null;
+        this.jc = (0, nats_ws_1.JSONCodec)();
         this.debug = debug;
-        this.subscribe = this.subscribe.bind(this);
-        this.unsubscribe = this.unsubscribe.bind(this);
-        this.createSubscriptions = this.createSubscriptions.bind(this);
-        this.clearSubscriptions = this.clearSubscriptions.bind(this);
-        this.resubscribe = this.resubscribe.bind(this);
-        this.setupStatusMonitoring = this.setupStatusMonitoring.bind(this);
-        this.isConnected = this.isConnected.bind(this);
-        this.getConnectionState = this.getConnectionState.bind(this);
     }
     log(level, message, data) {
         if (!this.debug && level === "debug")
@@ -162,7 +183,9 @@ class PubsubClient {
         }
         // If we're already connected to the same subject, just update handlers
         if (this.connectionState === ConnectionState.CONNECTED &&
-            this.subject === opts.subject) {
+            this.subject === opts.subject &&
+            this.streamName === opts.stream &&
+            this.consumerName === opts.consumer) {
             this.log("debug", "Already connected to same subject, updating handlers only");
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
@@ -179,13 +202,18 @@ class PubsubClient {
         }
         try {
             this.connectionState = ConnectionState.CONNECTING;
-            // Store the new configuration
+            // Store configuration
             this.subject = opts.subject;
             this.streamName = opts.stream;
             this.consumerName = opts.consumer;
             this.outputHandler = opts.onOutput || null;
             this.sessionHandler = opts.onSession || null;
             this.urlHandler = opts.onUrl || null;
+            this.maxMessages = opts.maxMessages || DEFAULT_MAX_MESSAGES;
+            this.expiresMs = opts.expiresMs || DEFAULT_EXPIRES_MS;
+            this.pollIntervalMs = opts.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+            this.threshold = Math.floor(this.maxMessages * DEFAULT_THRESHOLD_RATIO);
+            // Connect to NATS
             const inboxPrefix = `_INBOX_${opts.consumer}`;
             this.log("debug", `Connecting with inbox prefix: ${inboxPrefix}`);
             this.nc = await (0, nats_ws_1.connect)({
@@ -201,16 +229,11 @@ class PubsubClient {
             this.connectionState = ConnectionState.CONNECTED;
             this.log("info", "Connected successfully");
             this.setupStatusMonitoring();
-            await this.createSubscriptions(this.streamName, this.consumerName);
+            await this.createPullSubscription();
         }
         catch (error) {
             this.connectionState = ConnectionState.DISCONNECTED;
-            this.subject = null;
-            this.streamName = null;
-            this.consumerName = null;
-            this.outputHandler = null;
-            this.sessionHandler = null;
-            this.urlHandler = null;
+            this.cleanupState();
             if (this.nc) {
                 try {
                     await this.nc.close();
@@ -225,6 +248,8 @@ class PubsubClient {
         }
     }
     setupStatusMonitoring() {
+        if (!this.nc)
+            return;
         (async () => {
             try {
                 for await (const status of this.nc.status()) {
@@ -249,32 +274,24 @@ class PubsubClient {
                             }
                             break;
                         case "error":
-                            // Usually permissions errors
                             this.log("error", "Connection error:", status.data);
                             break;
                         case "update":
-                            // Cluster configuration update
                             this.log("debug", "Cluster update received:", status.data);
                             break;
                         case "ldm":
-                            // Lame Duck Mode - server is requesting clients to reconnect
                             this.log("warn", "Server requesting reconnection (LDM)");
                             break;
-                        // Debug events - usually can be safely ignored but useful for debugging
                         case "reconnecting":
                             this.log("debug", "Attempting to reconnect...");
                             break;
-                        case "pingTimer":
-                            // Ping timer events - very verbose, only log if debug is enabled
-                            if (this.debug) {
-                                this.log("debug", "Ping timer event");
-                            }
-                            break;
                         case "staleConnection":
                             this.log("warn", "Connection is stale, may reconnect soon");
                             break;
                         default:
-                            this.log("debug", `Unknown status event: ${status.type}`, status.data);
+                            if (status.type !== "pingTimer" || this.debug) {
+                                this.log("debug", `Status event: ${status.type}`, status.data);
+                            }
                     }
                 }
             }
@@ -285,180 +302,248 @@ class PubsubClient {
             }
         })();
     }
-    async createSubscriptions(streamName, consumerName) {
+    async createPullSubscription() {
+        if (!this.nc || !this.streamName || !this.consumerName) {
+            throw new Error("Not properly initialized");
+        }
         await this.clearSubscriptions();
         try {
-            this.log("info", `Creating pull subscription for consumer: ${consumerName} on stream: ${streamName}`);
-            const jc = (0, nats_ws_1.JSONCodec)();
-            const pullSubject = `$JS.API.CONSUMER.MSG.NEXT.${streamName}.${consumerName}`;
-            // Create inbox with proper prefix - let the system generate the unique part
-            const inbox = (0, nats_ws_1.createInbox)(`_INBOX_${consumerName}`);
-            const sub = this.nc.subscribe(inbox);
+            this.log("info", `Creating pull subscription for consumer: ${this.consumerName} on stream: ${this.streamName}`);
+            // Create inbox for receiving messages
+            this.inbox = (0, nats_ws_1.createInbox)(`_INBOX_${this.consumerName}`);
+            const sub = this.nc.subscribe(this.inbox);
             this.pullSubscription = sub;
-            // Track state
-            let pending = 0;
-            let pulling = false;
-            const maxMessages = 100;
-            const threshold = 50;
-            const pollInterval = 1000; // 1 second poll interval
-            // Pull messages with proper expiration
-            const pull = async (batch) => {
-                if (pulling)
-                    return;
-                pulling = true;
+            // Reset state
+            this.pending = 0;
+            this.pulling = false;
+            // Start message processing loop
+            this.processMessages(sub);
+            // Initial pull - use no_wait to check for immediate messages
+            this.log("debug", `Initial no_wait pull for ${this.maxMessages} messages`);
+            await this.pull(this.maxMessages, true);
+            // Schedule periodic pulls for long polling
+            this.schedulePull();
+            this.log("info", "Pull subscription created successfully");
+        }
+        catch (error) {
+            this.log("error", "Failed to create subscriptions:", error);
+            throw error;
+        }
+    }
+    async processMessages(sub) {
+        try {
+            for await (const msg of sub) {
+                if (this.connectionState === ConnectionState.CLOSING ||
+                    this.connectionState === ConnectionState.DISCONNECTED) {
+                    this.log("info", "Subscription closing");
+                    break;
+                }
                 try {
-                    // Set expires to slightly longer than poll interval to avoid accumulation
-                    const request = {
-                        batch,
-                        expires: (pollInterval + 500) * 1000000, // Poll interval + 500ms buffer, in nanoseconds
-                    };
-                    this.nc.publish(pullSubject, jc.encode(request), { reply: inbox });
-                    pending += batch;
-                    this.log("debug", `Pull request sent: batch=${batch}, pending=${pending}, expires=${request.expires}ns`);
+                    await this.handleMessage(msg);
                 }
-                finally {
-                    pulling = false;
+                catch (error) {
+                    this.log("error", "Error handling message:", error);
                 }
-            };
-            // Initial pull
-            this.log("debug", `Initial pull request for ${maxMessages} messages`);
-            pull(maxMessages);
-            // Set up periodic pulling
-            let pullTimer = null;
-            const schedulePull = () => {
-                if (pullTimer)
-                    clearTimeout(pullTimer);
-                pullTimer = setTimeout(() => {
-                    if (pending < threshold) {
-                        const pullCount = maxMessages - pending;
-                        this.log("debug", `Scheduled pull: pending=${pending} < threshold=${threshold}, pulling ${pullCount} more`);
-                        pull(pullCount);
-                    }
-                    else {
-                        this.log("debug", `Skipping scheduled pull: pending=${pending} >= threshold=${threshold}`);
+            }
+        }
+        catch (error) {
+            if (this.connectionState !== ConnectionState.CLOSING) {
+                this.log("error", "Message processing error:", error);
+            }
+        }
+    }
+    async handleMessage(msg) {
+        // Headers structure: has _code/_description directly, plus nested headers Map
+        const status = msg.headers.code;
+        const description = msg.headers.description;
+        this.log("debug", `Message: status=${status}, hasData=${msg.data?.length > 0}, subject=${msg.subject}`);
+        // Handle status messages (404, 408, 409, etc.)
+        if (status) {
+            await this.handleStatusMessage(status, description, msg);
+            return;
+        }
+        // Check for flow control
+        const flowControl = msg.headers.get("Nats-Msg-Size");
+        if (flowControl?.[0] === "FlowControl") {
+            this.log("debug", "Received flow control request, responding");
+            msg.respond();
+            return;
+        }
+        // Check if this is an actual data message
+        if (!msg.data || msg.data.length === 0) {
+            this.log("debug", `Empty message on ${msg.subject}`);
+            return;
+        }
+        // Get the actual stream subject from headers
+        let streamSubject = msg.headers.get("Nats-Subject")?.[0];
+        // Fallback: use the message subject itself if it matches our pattern
+        if (!streamSubject && this.subject && !msg.subject.startsWith("_INBOX")) {
+            streamSubject = msg.subject;
+        }
+        if (!streamSubject) {
+            this.log("debug", "Message without valid stream subject");
+            return;
+        }
+        // We got a real message
+        this.pending = Math.max(0, this.pending - 1);
+        this.log("debug", `Message received on ${streamSubject}, pending=${this.pending}`);
+        // Process the message
+        const parts = streamSubject.split(".");
+        const action = parts[parts.length - 1];
+        this.log("info", `↓ message: ${action} on ${streamSubject}`);
+        try {
+            switch (action) {
+                case "output": {
+                    if (this.outputHandler) {
+                        const output = (0, protobuf_1.fromBinary)(automations_pb_js_1.OutputSchema, msg.data);
+                        this.outputHandler({
+                            vertex: output.vertex,
+                            fork: output.fork,
+                            data: parseOutputData(output.data),
+                            created: (0, wkt_1.timestampDate)(output.created),
+                        });
                     }
-                }, pollInterval);
-            };
-            // Process messages
-            (async () => {
-                try {
-                    for await (const msg of sub) {
-                        if (this.connectionState === ConnectionState.CLOSING ||
-                            this.connectionState === ConnectionState.DISCONNECTED) {
-                            this.log("info", "Subscription closing");
-                            if (pullTimer)
-                                clearTimeout(pullTimer);
-                            break;
-                        }
-                        // Check status header
-                        const status = msg.headers?.get("Status");
-                        if (status === "404") {
-                            // No messages available
-                            this.log("debug", "No messages available (404), resetting pending to 0");
-                            pending = 0;
-                            schedulePull();
-                            continue;
-                        }
-                        if (status === "408") {
-                            this.log("debug", "Pull request timed out (408), resetting pending and pulling immediately");
-                            pending = 0;
-                            pull(maxMessages); // Immediately pull again instead of scheduling
-                            continue;
-                        }
-                        if (status === "409") {
-                            this.log("warn", "Max ack pending reached (409), waiting 5 seconds before retry");
-                            pending = 0;
-                            setTimeout(() => pull(maxMessages), 5000);
-                            continue;
-                        }
-                        // Skip if not a real message
-                        if (!msg.data || msg.data.length === 0 || msg.subject === inbox) {
-                            this.log("debug", `Skipping non-message: data=${msg.data?.length || 0} bytes, subject=${msg.subject}`);
-                            continue;
-                        }
-                        // We got a real message
-                        pending = Math.max(0, pending - 1);
-                        this.log("debug", `Message received, pending decreased to ${pending}`);
-                        // Re-pull if below threshold
-                        if (pending < threshold && !pulling) {
-                            const pullCount = maxMessages - pending;
-                            this.log("debug", `Pending ${pending} < threshold ${threshold}, pulling ${pullCount} more messages`);
-                            pull(pullCount);
-                        }
-                        const parts = msg.subject.split(".");
-                        const action = parts[parts.length - 1];
-                        this.log("info", `↓ message: ${action} on ${msg.subject}`);
-                        try {
-                            switch (action) {
-                                case "output": {
-                                    if (this.outputHandler) {
-                                        const output = (0, protobuf_1.fromBinary)(automations_pb_js_1.OutputSchema, msg.data);
-                                        this.outputHandler({
-                                            vertex: output.vertex,
-                                            fork: output.fork,
-                                            data: parseOutputData(output.data),
-                                            created: (0, wkt_1.timestampDate)(output.created),
-                                        });
-                                    }
-                                    break;
-                                }
-                                case "session": {
-                                    if (this.sessionHandler) {
-                                        const session = (0, protobuf_1.fromBinary)(automations_pb_js_1.SessionSchema, msg.data);
-                                        this.sessionHandler((0, protobuf_1.toJson)(automations_pb_js_1.SessionSchema, session));
-                                    }
-                                    break;
-                                }
-                                case "url": {
-                                    if (this.urlHandler) {
-                                        const url = (0, protobuf_1.fromBinary)(automations_pb_js_1.UrlSchema, msg.data);
-                                        this.urlHandler((0, protobuf_1.toJson)(automations_pb_js_1.UrlSchema, url));
-                                    }
-                                    break;
-                                }
-                                default:
-                                    this.log("warn", `Unknown message action: ${action}`);
-                            }
-                            // ACK the message
-                            const ackSuccess = msg.respond();
-                            if (!ackSuccess) {
-                                this.log("warn", "Failed to ACK message");
-                            }
-                            else {
-                                this.log("debug", `Message ACKed successfully for action: ${action}`);
-                            }
-                        }
-                        catch (error) {
-                            this.log("error", "Error handling message:", error);
-                            // NAK the message for redelivery
-                            const nakSuccess = msg.respond(new TextEncoder().encode("-NAK"));
-                            if (!nakSuccess) {
-                                this.log("warn", "Failed to NAK message");
-                            }
-                            else {
-                                this.log("debug", "Message NAKed for redelivery");
-                            }
-                        }
+                    break;
+                }
+                case "session": {
+                    if (this.sessionHandler) {
+                        const session = (0, protobuf_1.fromBinary)(automations_pb_js_1.SessionSchema, msg.data);
+                        this.sessionHandler((0, protobuf_1.toJson)(automations_pb_js_1.SessionSchema, session));
                     }
+                    break;
                 }
-                catch (error) {
-                    if (this.connectionState !== ConnectionState.CLOSING) {
-                        this.log("error", "Handler error:", error);
+                case "url": {
+                    if (this.urlHandler) {
+                        const url = (0, protobuf_1.fromBinary)(automations_pb_js_1.UrlSchema, msg.data);
+                        this.urlHandler((0, protobuf_1.toJson)(automations_pb_js_1.UrlSchema, url));
                     }
+                    break;
+                }
+                default:
+                    this.log("warn", `Unknown message action: ${action}`);
+            }
+            // ACK the message
+            if (msg.reply) {
+                msg.respond(ACK_POSITIVE);
+                this.log("debug", `Message ACKed for ${action}`);
+            }
+        }
+        catch (error) {
+            this.log("error", "Error processing message:", error);
+            // NAK the message for redelivery
+            if (msg.reply) {
+                msg.respond(ACK_NEGATIVE);
+            }
+            throw error;
+        }
+        // Pull more if below threshold
+        if (this.pending < this.threshold && !this.pulling) {
+            const pullCount = this.maxMessages - this.pending;
+            this.log("debug", `Pulling ${pullCount} more messages`);
+            this.pull(pullCount, false);
+        }
+    }
+    async handleStatusMessage(status, description, msg) {
+        switch (status) {
+            case STATUS_NO_MESSAGES:
+                this.log("debug", `No messages available: ${description}`);
+                this.pending = 0;
+                break;
+            case STATUS_REQUEST_TIMEOUT:
+                this.log("debug", `Request timeout: ${description}`);
+                if (this.pending > 0) {
+                    this.pending--;
                 }
-                finally {
-                    if (pullTimer)
-                        clearTimeout(pullTimer);
+                // Check if we have pending messages info
+                const pendingMsgs = msg.headers.get("Nats-Pending-Messages")?.[0];
+                if (pendingMsgs) {
+                    this.log("debug", `Server reports ${pendingMsgs} pending messages`);
                 }
-            })();
-            this.log("info", "Pull subscription created successfully");
+                break;
+            case STATUS_MAX_ACK_PENDING:
+                this.log("warn", `Max ack pending: ${description}`);
+                this.pending = 0;
+                // Wait before retry
+                setTimeout(() => {
+                    if (this.connectionState === ConnectionState.CONNECTED) {
+                        this.pull(this.maxMessages, false);
+                    }
+                }, 5000);
+                break;
+            case STATUS_FLOW_CONTROL:
+                this.log("debug", `Flow control: ${description}`);
+                if (msg.reply) {
+                    msg.respond();
+                }
+                break;
+            default:
+                this.log("debug", `Unknown status ${status}: ${description}`);
+        }
+    }
+    async pull(batch, noWait = false) {
+        if (this.pulling || !this.nc || !this.inbox || batch <= 0) {
+            return;
+        }
+        if (this.connectionState !== ConnectionState.CONNECTED) {
+            return;
+        }
+        this.pulling = true;
+        try {
+            const pullSubject = `${CONSUMER_MSG_NEXT_PREFIX}${this.streamName}.${this.consumerName}`;
+            const request = {
+                batch: batch,
+            };
+            if (noWait) {
+                request.no_wait = true;
+            }
+            else if (this.expiresMs > 0) {
+                request.expires = this.expiresMs * 1000000; // Convert to nanoseconds
+            }
+            this.nc.publish(pullSubject, this.jc.encode(request), {
+                reply: this.inbox,
+            });
+            this.pending += batch;
+            this.log("debug", `Pull sent: batch=${batch}, pending=${this.pending}, noWait=${noWait}`);
         }
         catch (error) {
-            this.log("error", "Failed to create subscriptions:", error);
+            this.log("error", "Error sending pull request:", error);
+            this.pending = Math.max(0, this.pending - batch);
             throw error;
         }
+        finally {
+            this.pulling = false;
+        }
+    }
+    schedulePull() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+        }
+        if (this.connectionState !== ConnectionState.CONNECTED) {
+            return;
+        }
+        this.pullTimer = setTimeout(() => {
+            if (this.connectionState !== ConnectionState.CONNECTED) {
+                return;
+            }
+            // Maintain batch size
+            if (this.pending < this.threshold && !this.pulling) {
+                const pullCount = this.maxMessages - this.pending;
+                this.log("debug", `Scheduled pull: ${pullCount} messages`);
+                this.pull(pullCount, false);
+            }
+            else if (this.pending === 0 && !this.pulling) {
+                // No pending at all, pull full batch
+                this.log("debug", "No pending, pulling full batch");
+                this.pull(this.maxMessages, false);
+            }
+            this.schedulePull();
+        }, this.pollIntervalMs);
     }
     async clearSubscriptions() {
+        if (this.pullTimer) {
+            clearTimeout(this.pullTimer);
+            this.pullTimer = null;
+        }
         if (!this.pullSubscription)
             return;
         this.log("debug", "Clearing subscription");
@@ -472,10 +557,27 @@ class PubsubClient {
         this.pullSubscription = null;
     }
     async resubscribe() {
-        // Only called when we have an active connection that needs resubscription
-        await this.createSubscriptions(this.streamName, this.consumerName);
+        if (!this.streamName || !this.consumerName)
+            return;
+        this.log("info", "Resubscribing after reconnection");
+        // Clear old state
+        this.pending = 0;
+        this.pulling = false;
+        // Recreate subscription
+        await this.createPullSubscription();
         this.log("info", "✓ Resubscribed successfully");
     }
+    cleanupState() {
+        this.subject = null;
+        this.streamName = null;
+        this.consumerName = null;
+        this.outputHandler = null;
+        this.sessionHandler = null;
+        this.urlHandler = null;
+        this.inbox = null;
+        this.pending = 0;
+        this.pulling = false;
+    }
     async unsubscribe() {
         if (this.connectionState === ConnectionState.DISCONNECTED ||
             this.connectionState === ConnectionState.CLOSING) {
@@ -484,12 +586,7 @@ class PubsubClient {
         this.log("info", "Starting unsubscribe process");
         this.connectionState = ConnectionState.CLOSING;
         await this.clearSubscriptions();
-        this.outputHandler = null;
-        this.sessionHandler = null;
-        this.urlHandler = null;
-        this.subject = null;
-        this.streamName = null;
-        this.consumerName = null;
+        this.cleanupState();
         this.isReconnecting = false;
         if (this.nc && !this.nc.isClosed()) {
             try {
@@ -512,6 +609,7 @@ class PubsubClient {
     }
 }
 exports.PubsubClient = PubsubClient;
+// Helper functions
 function validateSubject(subject) {
     if (!subject || subject.includes(" ") || subject.includes("\t")) {
         return false;
@@ -529,7 +627,6 @@ function parseOutputData(data) {
             return [key, JSON.parse(new TextDecoder().decode(value))];
         }
         catch (error) {
-            // Note: We don't have access to the log method here, so we keep console.error
             console.error(`Failed to parse data for key ${key}:`, error);
             return [key, null];
         }