@tylerl0706/ahpx 0.2.0

package/dist/index.js

@@ -0,0 +1,229 @@
+import {
+  ActionType,
+  ActiveClientManager,
+  AhpClient,
+  AuthHandler,
+  ForwardingFormatter,
+  HealthChecker,
+  PendingMessageKind,
+  ProtocolLayer,
+  ReconnectManager,
+  ResponsePartKind,
+  RpcError,
+  RpcTimeoutError,
+  SessionHandle,
+  SessionLifecycle,
+  SessionPersistence,
+  SessionStatus,
+  SessionStore,
+  StateMirror,
+  ToolCallStatus,
+  Transport,
+  WebSocketForwarder,
+  WebhookForwarder,
+  buildTurnSummary,
+  ensureFileUri,
+  fileUriToDisplayPath,
+  truncatePreview
+} from "./chunk-B6RV43UP.js";
+
+// src/client/connection-pool.ts
+var ConnectionPool = class {
+  _clients = /* @__PURE__ */ new Map();
+  _maxPerServer;
+  constructor(options) {
+    this._maxPerServer = options?.maxConnectionsPerServer ?? 1;
+  }
+  /**
+   * Get or create a connected client for the given server URL.
+   *
+   * If a connected client already exists for this URL, it is returned.
+   * Otherwise a new client is created, connected, and cached.
+   */
+  async getClient(url, options) {
+    const normalizedUrl = this.normalizeUrl(url);
+    const existing = this._clients.get(normalizedUrl);
+    if (existing?.connected) {
+      return existing;
+    }
+    if (existing) {
+      this._clients.delete(normalizedUrl);
+    }
+    const client = new AhpClient(options);
+    await client.connect(url);
+    client.on("disconnected", () => {
+      this._clients.delete(normalizedUrl);
+    });
+    this._clients.set(normalizedUrl, client);
+    return client;
+  }
+  /**
+   * Close all connections in the pool.
+   */
+  async closeAll() {
+    const clients = [...this._clients.values()];
+    this._clients.clear();
+    await Promise.all(
+      clients.map(
+        (client) => client.disconnect().catch(() => {
+        })
+      )
+    );
+  }
+  /** Number of active connections in the pool. */
+  get activeConnections() {
+    return this._clients.size;
+  }
+  /** Total number of active sessions across all connections. */
+  get activeSessions() {
+    let total = 0;
+    for (const client of this._clients.values()) {
+      total += client.sessions.size;
+    }
+    return total;
+  }
+  normalizeUrl(url) {
+    return url.replace(/\/+$/, "");
+  }
+};
+
+// src/fleet/manager.ts
+var FleetManager = class {
+  _connections;
+  _strategy;
+  _preferredServer;
+  _tags;
+  _checker;
+  _healthCache = [];
+  _roundRobinIndex = 0;
+  constructor(options) {
+    this._connections = options.connections;
+    this._strategy = options.strategy ?? "least-sessions";
+    this._preferredServer = options.preferredServer;
+    this._checker = new HealthChecker({ timeout: options.healthCheckTimeout });
+    const tags = {};
+    if (options.tags) {
+      for (const [tag, names] of Object.entries(options.tags)) {
+        tags[tag] = [...names];
+      }
+    }
+    for (const conn of options.connections) {
+      if (conn.tags) {
+        for (const tag of conn.tags) {
+          if (!tags[tag]) {
+            tags[tag] = [];
+          }
+          if (!tags[tag].includes(conn.name)) {
+            tags[tag].push(conn.name);
+          }
+        }
+      }
+    }
+    this._tags = tags;
+  }
+  /** Pick the best server for a dispatch based on strategy and requirements. */
+  async selectServer(requirements) {
+    if (this._healthCache.length === 0) {
+      await this.refresh();
+    }
+    let candidates = this._healthCache.filter((h) => h.status === "healthy");
+    if (requirements?.provider) {
+      const provider = requirements.provider;
+      candidates = candidates.filter((h) => h.agents.some((a) => a.provider === provider));
+    }
+    if (requirements?.model) {
+      const model = requirements.model;
+      candidates = candidates.filter((h) => h.agents.some((a) => a.models.includes(model)));
+    }
+    if (requirements?.tag) {
+      const tag = requirements.tag;
+      const serversWithTag = this._tags[tag] ?? [];
+      candidates = candidates.filter((h) => serversWithTag.includes(h.name));
+    }
+    if (candidates.length === 0) {
+      throw new Error("No healthy server matches the requirements");
+    }
+    const selected = this._applyStrategy(candidates);
+    return { name: selected.name, url: selected.url };
+  }
+  /** Get health for all servers (cached). */
+  async getHealth() {
+    if (this._healthCache.length === 0) {
+      await this.refresh();
+    }
+    return [...this._healthCache];
+  }
+  /** Refresh health cache by checking all servers. */
+  async refresh() {
+    this._healthCache = await this._checker.checkAll(this._connections);
+  }
+  _applyStrategy(candidates) {
+    switch (this._strategy) {
+      case "least-sessions":
+        return this._leastSessions(candidates);
+      case "round-robin": {
+        const index = this._roundRobinIndex % candidates.length;
+        this._roundRobinIndex = (this._roundRobinIndex + 1) % candidates.length;
+        return candidates[index];
+      }
+      case "random":
+        return candidates[Math.floor(Math.random() * candidates.length)];
+      case "preferred": {
+        if (this._preferredServer) {
+          const preferred = candidates.find((h) => h.name === this._preferredServer);
+          if (preferred) {
+            return preferred;
+          }
+        }
+        return this._leastSessions(candidates);
+      }
+    }
+  }
+  _leastSessions(candidates) {
+    let best = candidates[0];
+    for (let i = 1; i < candidates.length; i++) {
+      if (candidates[i].activeSessions < best.activeSessions) {
+        best = candidates[i];
+      }
+    }
+    return best;
+  }
+};
+
+// src/protocol/commands.ts
+var ContentEncoding = /* @__PURE__ */ ((ContentEncoding2) => {
+  ContentEncoding2["Base64"] = "base64";
+  ContentEncoding2["Utf8"] = "utf-8";
+  return ContentEncoding2;
+})(ContentEncoding || {});
+export {
+  ActionType,
+  ActiveClientManager,
+  AhpClient,
+  AuthHandler,
+  ConnectionPool,
+  ContentEncoding,
+  FleetManager,
+  ForwardingFormatter,
+  HealthChecker,
+  PendingMessageKind,
+  ProtocolLayer,
+  ReconnectManager,
+  ResponsePartKind,
+  RpcError,
+  RpcTimeoutError,
+  SessionHandle,
+  SessionLifecycle,
+  SessionPersistence,
+  SessionStatus,
+  SessionStore,
+  StateMirror,
+  ToolCallStatus,
+  Transport,
+  WebSocketForwarder,
+  WebhookForwarder,
+  buildTurnSummary,
+  ensureFileUri,
+  fileUriToDisplayPath,
+  truncatePreview
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "@tylerl0706/ahpx",
+	"version": "0.2.0",
+	"type": "module",
+	"description": "Agent Host Protocol client — use as a library or CLI to manage AHP server connections, sessions, and agent interactions",
+	"license": "MIT",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./cli": {
+			"import": "./dist/bin.js"
+		}
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"bin": {
+		"ahpx": "./dist/bin.js"
+	},
+	"files": ["dist", "LICENSE"],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/TylerLeonhardt/ahpx.git"
+	},
+	"homepage": "https://github.com/TylerLeonhardt/ahpx#readme",
+	"bugs": {
+		"url": "https://github.com/TylerLeonhardt/ahpx/issues"
+	},
+	"keywords": ["ahp", "agent-host-protocol", "cli", "agent", "ai", "websocket", "json-rpc"],
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"commander": "^13.1.0",
+		"picocolors": "^1.1.1",
+		"ws": "^8.18.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@types/node": "^22.13.10",
+		"@types/ws": "^8.5.14",
+		"tsup": "^8.4.0",
+		"typescript": "^5.8.2",
+		"vitest": "^3.0.9"
+	}
+}