cartethyia 2.5.3 → 2.5.6

package/src/console/routing/pools/probe-result.ts

@@ -51,8 +51,9 @@ export function classifyPoolConnectError(
   error: unknown,
   latencyMs: number,
 ): HealthCheckResult | undefined {
-  // The agent throws a typed refusal carrying the status, so this no longer
-  // re-parses the message text (which a wording change would silently break).
+  // The agent throws a typed refusal carrying the status, so this reads the
+  // status rather than re-parsing message text (which a wording change would
+  // silently break).
   if (!(error instanceof ProxyConnectRefusalError)) return undefined;
   if (error.statusCode !== 402 && error.statusCode !== 407) return undefined;
   return classifyPoolProbeResponse(poolId, { ok: false, status: error.statusCode }, latencyMs);

package/src/console/routing/pools/probe-verdict.ts

@@ -1,132 +1,132 @@
-/**
- * What one provider-probe answer means about the egress.
- *
- * Extracted from the store so the console, the CLI probe
- * (`scripts/operations/probe-egress.ts`) and the tests cannot drift into three
- * readings of the same response. The rule that matters is not obvious:
- *
- * **The provider's IP gate runs before it validates the body.** So a `4xx`
- * complaint about the payload proves the address was accepted — it is the
- * probe's request that is wrong, not the proxy. Mapping that to `unreachable`
- * ("the probe could not complete") blamed the proxy for our own defect and hid
- * working egresses behind a verdict that said the pool was unusable.
- *
- * Only the free-tier refusal retires an address. Every other answer either says
- * the address works (`allowed`, `throttled`) or says nothing about it
- * (`unreachable`), and treating "says nothing" as "refused" would drop a usable
- * pool for good.
- */
-
-export type ProbeVerdict = "allowed" | "blocked" | "throttled" | "unreachable";
-
-export interface ProbeAnswer {
-  readonly status: ProbeVerdict;
-  /** Operator-facing reason; absent when the answer needs none. */
-  readonly reason?: string;
-}
-
-/** The upstream's own wording for "this address is retired". */
-const FREE_TIER_REFUSAL = /freetier|free tier can only be used/i;
-
-/**
- * Classifies one upstream response.
- *
- * `407` is separated from the generic 4xx branch on purpose: it comes from the
- * proxy front door, never from the provider, so it is a credential problem on
- * the tunnel and says nothing about whether the address is refused.
- */
-export function classifyProviderProbeAnswer(httpStatus: number, body: string): ProbeAnswer {
-  if (httpStatus === 403 && FREE_TIER_REFUSAL.test(body)) {
-    return { status: "blocked", reason: "Upstream refused this egress address" };
-  }
-  if (httpStatus === 407) {
-    return { status: "unreachable", reason: "Proxy requires authentication" };
-  }
-  if (httpStatus === 429) {
-    return { status: "throttled", reason: "Address accepted; rate limit spent" };
-  }
-  if (httpStatus >= 200 && httpStatus < 300) {
-    return { status: "allowed" };
-  }
-  if (httpStatus >= 500) {
-    return { status: "unreachable", reason: `Upstream answered ${httpStatus}` };
-  }
-  // Any other 4xx: the request reached the upstream's own validation, which
-  // only happens once the address is accepted.
-  return {
-    status: "allowed",
-    reason: `Reachable; upstream answered ${httpStatus} for the probe body`,
-  };
-}
-
-/**
- * Error codes that mean "this attempt never reached the upstream", not "the
- * upstream refused this address".
- *
- * Every one of them is worth a second attempt, and the reason is the same in
- * each case: the failure is a property of one socket, not of the egress. A
- * proxy that has just been dialled for the first time has to resolve, open a
- * tunnel, and complete a TLS handshake, and any of those steps can be refused
- * or reset by a middlebox that accepts the very next attempt — which is exactly
- * the "fails once, works on retry" report. Retiring the pool on the first one
- * blames the address for a cold-start race.
- */
-const RETRYABLE_TRANSPORT_CODES = new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ECONNABORTED",
-  "EHOSTUNREACH",
-  "ENETUNREACH",
-  "ENETRESET",
-  "EPIPE",
-  "ETIMEDOUT",
-  "EAI_AGAIN",
-  "UND_ERR_SOCKET",
-  "UND_ERR_CONNECT_TIMEOUT",
-  "ECONNECT_TIMEOUT",
-]);
-/** How many `cause` links to follow; wraps are shallow in practice. */
-const PROBE_ERROR_CAUSE_DEPTH = 5;
-
-/**
- * Whether one probe error should be retried before it becomes a verdict.
- *
- * Deliberately narrow: an abort is *our* deadline firing, so retrying it would
- * spend the whole probe budget on a slow egress, and an unknown error is left
- * alone rather than guessed at. Only transport codes that describe a single
- * dead connection qualify.
- */
-export function isRetryableProbeError(error: unknown): boolean {
-
-  // Walk the `cause` chain: a transport failure is routinely wrapped — the
-  // proxy layer raises `ProxyConnectHandshakeError` whose *message* carries the
-  // real code, with nothing on `code`. Checking only the top error would miss
-  // exactly the failure this exists for.
-  let current: unknown = error;
-  for (let depth = 0; depth < PROBE_ERROR_CAUSE_DEPTH && current !== undefined && current !== null; depth += 1) {
-    if (!(current instanceof Error)) break;
-    if (current.name === "AbortError" || current.name === "TimeoutError") return false;
-    // `code` is not on the base `Error`; narrow before reading it rather than
-    // asserting a shape the runtime may not have.
-    const code: string | undefined =
-      "code" in current && typeof current.code === "string" ? current.code : undefined;
-    if (code !== undefined && RETRYABLE_TRANSPORT_CODES.has(code.toUpperCase())) return true;
-    const message = String(current.message ?? "");
-    // The wrapped code is often only in the message, so match it there too.
-    for (const candidate of RETRYABLE_TRANSPORT_CODES) {
-      if (message.includes(candidate)) return true;
-    }
-    if (
-      message.includes("fetch failed") ||
-      message.includes("socket connection was closed unexpectedly") ||
-      message.includes("other side closed") ||
-      message.startsWith("terminated") ||
-      /connection (?:was|is) closed/i.test(message)
-    ) {
-      return true;
-    }
-    current = current.cause;
-  }
-  return false;
-}
-
+/**
+ * What one provider-probe answer means about the egress.
+ *
+ * Extracted from the store so the console, the CLI probe
+ * (`scripts/tools/probe-egress.ts`) and the tests cannot drift into three
+ * readings of the same response. The rule that matters is not obvious:
+ *
+ * **The provider's IP gate runs before it validates the body.** So a `4xx`
+ * complaint about the payload proves the address was accepted — it is the
+ * probe's request that is wrong, not the proxy. Mapping that to `unreachable`
+ * ("the probe could not complete") blamed the proxy for our own defect and hid
+ * working egresses behind a verdict that said the pool was unusable.
+ *
+ * Only the free-tier refusal retires an address. Every other answer either says
+ * the address works (`allowed`, `throttled`) or says nothing about it
+ * (`unreachable`), and treating "says nothing" as "refused" would drop a usable
+ * pool for good.
+ */
+
+export type ProbeVerdict = "allowed" | "blocked" | "throttled" | "unreachable";
+
+export interface ProbeAnswer {
+  readonly status: ProbeVerdict;
+  /** Operator-facing reason; absent when the answer needs none. */
+  readonly reason?: string;
+}
+
+/** The upstream's own wording for "this address is retired". */
+const FREE_TIER_REFUSAL = /freetier|free tier can only be used/i;
+
+/**
+ * Classifies one upstream response.
+ *
+ * `407` is separated from the generic 4xx branch on purpose: it comes from the
+ * proxy front door, never from the provider, so it is a credential problem on
+ * the tunnel and says nothing about whether the address is refused.
+ */
+export function classifyProviderProbeAnswer(httpStatus: number, body: string): ProbeAnswer {
+  if (httpStatus === 403 && FREE_TIER_REFUSAL.test(body)) {
+    return { status: "blocked", reason: "Upstream refused this egress address" };
+  }
+  if (httpStatus === 407) {
+    return { status: "unreachable", reason: "Proxy requires authentication" };
+  }
+  if (httpStatus === 429) {
+    return { status: "throttled", reason: "Address accepted; rate limit spent" };
+  }
+  if (httpStatus >= 200 && httpStatus < 300) {
+    return { status: "allowed" };
+  }
+  if (httpStatus >= 500) {
+    return { status: "unreachable", reason: `Upstream answered ${httpStatus}` };
+  }
+  // Any other 4xx: the request reached the upstream's own validation, which
+  // only happens once the address is accepted.
+  return {
+    status: "allowed",
+    reason: `Reachable; upstream answered ${httpStatus} for the probe body`,
+  };
+}
+
+/**
+ * Error codes that mean "this attempt never reached the upstream", not "the
+ * upstream refused this address".
+ *
+ * Every one of them is worth a second attempt, and the reason is the same in
+ * each case: the failure is a property of one socket, not of the egress. A
+ * proxy that has just been dialled for the first time has to resolve, open a
+ * tunnel, and complete a TLS handshake, and any of those steps can be refused
+ * or reset by a middlebox that accepts the very next attempt — which is exactly
+ * the "fails once, works on retry" report. Retiring the pool on the first one
+ * blames the address for a cold-start race.
+ */
+const RETRYABLE_TRANSPORT_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ECONNABORTED",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENETRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "UND_ERR_SOCKET",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "ECONNECT_TIMEOUT",
+]);
+/** How many `cause` links to follow; wraps are shallow in practice. */
+const PROBE_ERROR_CAUSE_DEPTH = 5;
+
+/**
+ * Whether one probe error should be retried before it becomes a verdict.
+ *
+ * Deliberately narrow: an abort is *our* deadline firing, so retrying it would
+ * spend the whole probe budget on a slow egress, and an unknown error is left
+ * alone rather than guessed at. Only transport codes that describe a single
+ * dead connection qualify.
+ */
+export function isRetryableProbeError(error: unknown): boolean {
+
+  // Walk the `cause` chain: a transport failure is routinely wrapped — the
+  // proxy layer raises `ProxyConnectHandshakeError` whose *message* carries the
+  // real code, with nothing on `code`. Checking only the top error would miss
+  // exactly the failure this exists for.
+  let current: unknown = error;
+  for (let depth = 0; depth < PROBE_ERROR_CAUSE_DEPTH && current !== undefined && current !== null; depth += 1) {
+    if (!(current instanceof Error)) break;
+    if (current.name === "AbortError" || current.name === "TimeoutError") return false;
+    // `code` is not on the base `Error`; narrow before reading it rather than
+    // asserting a shape the runtime may not have.
+    const code: string | undefined =
+      "code" in current && typeof current.code === "string" ? current.code : undefined;
+    if (code !== undefined && RETRYABLE_TRANSPORT_CODES.has(code.toUpperCase())) return true;
+    const message = String(current.message ?? "");
+    // The wrapped code is often only in the message, so match it there too.
+    for (const candidate of RETRYABLE_TRANSPORT_CODES) {
+      if (message.includes(candidate)) return true;
+    }
+    if (
+      message.includes("fetch failed") ||
+      message.includes("socket connection was closed unexpectedly") ||
+      message.includes("other side closed") ||
+      message.startsWith("terminated") ||
+      /connection (?:was|is) closed/i.test(message)
+    ) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+

package/src/console/routing/pools/routes.ts

@@ -1,164 +1,181 @@
-// Network-pool control-plane HTTP routes. The only module that touches Elysia.
-import { Elysia, t } from "elysia";
-import { consoleErrorHandler } from "../../shared/errors";
-import { literalUnion } from "../../shared/elysia-schema";
-import { RELAY_TARGETS, type RelayDeployRequest } from "./relay-deploy";
-import { RELAY_REGIONS } from "./relay-regions";
-import { SPEED_TEST_DEFAULT_BYTES } from "./speed-test-sizes";
-import {
-  MAX_BATCH_PROBE_TARGETS,
-  POOL_KINDS,
-  POOL_ROUTING_STRATEGIES,
-  POOL_STATUSES,
-  type CreateNetworkPoolRequest,
-  type NetworkPoolConfig,
-  type PoolStrategySetting,
-} from "./contracts";
-import { createNetworkPoolOperations } from "./operations";
-
-const poolKindSchema = literalUnion(POOL_KINDS);
-const createPoolBody = t.Object({
-  kind: poolKindSchema,
-  label: t.Optional(t.String()),
-  endpoint: t.String(),
-  credential: t.Optional(t.String()),
-  maxInflight: t.Optional(t.Number()),
-  weight: t.Optional(t.Number()),
-  status: t.Optional(literalUnion(POOL_STATUSES)),
-  config: t.Optional(t.Record(t.String(), t.Unknown())),
-  /** Egress allowance in bytes; `null` clears it back to unmetered. */
-  quotaBytes: t.Optional(t.Union([t.Number({ minimum: 1 }), t.Null()])),
-  /** Operator-set family/tag naming which family this node belongs to. */
-  family: t.Optional(t.Union([t.String(), t.Null()])),
-});
-const deployRelayBody = t.Object({
-  target: literalUnion(RELAY_TARGETS),
-  token: t.String({ minLength: 1 }),
-  accountId: t.Optional(t.String()),
-  projectName: t.Optional(t.String()),
-  /** Vercel function region; ignored for targets that have no region control. */
-  region: t.Optional(literalUnion(RELAY_REGIONS)),
-});
-const testBatchBody = t.Object({
-  targets: t.Array(createPoolBody, { minItems: 1, maxItems: MAX_BATCH_PROBE_TARGETS }),
-});
-const updatePoolBody = t.Partial(createPoolBody);
-export function createNetworkPoolRoutes(config: NetworkPoolConfig): Elysia {
-  const factory = createNetworkPoolOperations(config);
-  return new Elysia({ prefix: "/network/pools" })
-    .error(consoleErrorHandler("Network pool operation failed"))
-    .get("/", async ({ request }) => {
-      return await factory.listPools(config.accessResolver(request));
-})
-    .get("/:poolId", async ({ request, params }) => {
-      return await factory.getPoolDetail(config.accessResolver(request), params.poolId);
-})
-    .post("/", { body: createPoolBody }, async ({ request, body, set }) => {
-      set.status = 201;
-      return await factory.createPool(
-        config.accessResolver(request),
-        body as CreateNetworkPoolRequest,
-      );
-})
-    .patch("/:poolId", { body: updatePoolBody }, async ({ request, params, body }) => {
-      return await factory.updatePool(
-        config.accessResolver(request),
-        params.poolId,
-        body as Partial<CreateNetworkPoolRequest>,
-      );
-})
-    .delete("/:poolId", async ({ request, params }) => {
-      return await factory.deletePool(config.accessResolver(request), params.poolId);
-})
-    .get("/:poolId/health-events", async ({ request, params }) => {
-      return await factory.listPoolHealthEvents(config.accessResolver(request), params.poolId);
-})
-    .post("/:poolId/recover", async ({ request, params }) => {
-      return await factory.recoverPool(config.accessResolver(request), params.poolId);
-})
-    .post(
-      "/:poolId/provider-probe",
-      { body: t.Object({ providerId: t.String() }) },
-      async ({ request, params, body }) => {
-        return await factory.providerProbe(
-          config.accessResolver(request),
-          params.poolId,
-          body.providerId,
-        );
-      },
-    )
-    .post("/:poolId/health-check", async ({ request, params }) => {
-      return await factory.healthCheck(config.accessResolver(request), params.poolId);
-})
-    .post(
-      "/:poolId/speed-test",
-      { body: t.Optional(t.Object({ bytes: t.Optional(t.Number()) })) },
-      async ({ request, params, body }) => {
-        return await factory.speedTest(
-          config.accessResolver(request),
-          params.poolId,
-          body?.bytes ?? SPEED_TEST_DEFAULT_BYTES,
-        );
-      },
-    )
-    .post("/test", { body: createPoolBody }, async ({ request, body }) => {
-      return await factory.probeAdHocPool(
-        config.accessResolver(request),
-        body as CreateNetworkPoolRequest,
-      );
-})
-    .post("/test-batch", { body: testBatchBody }, async ({ request, body }) => {
-      return await factory.probeAdHocPoolBatch(
-        config.accessResolver(request),
-        body.targets as CreateNetworkPoolRequest[],
-      );
-})
-    .post(
-      "/test-batch/provider",
-      {
-        body: t.Object({
-          providerId: t.String(),
-          targets: t.Array(createPoolBody, { minItems: 1, maxItems: MAX_BATCH_PROBE_TARGETS }),
-        }),
-      },
-      async ({ request, body }) => {
-        return await factory.probeAdHocProviderBatch(
-          config.accessResolver(request),
-          body.targets as CreateNetworkPoolRequest[],
-          body.providerId,
-        );
-      },
-    )
-    .post(
-      "/:poolId/cooldowns/clear",
-      { body: t.Optional(t.Object({ providerId: t.Optional(t.String()) })) },
-      async ({ request, params, body }) => {
-        return await factory.clearPoolCooldown(
-          config.accessResolver(request),
-          params.poolId,
-          body?.providerId,
-        );
-},
-    )
-    .post("/relay/deploy", { body: deployRelayBody }, async ({ request, body }) => {
-      return await factory.deployRelay(config.accessResolver(request), body as RelayDeployRequest);
-    })
-    .get("/strategy", async ({ request }) => {
-      return await factory.getStrategy(config.accessResolver(request));
-})
-    .patch(
-      "/strategy",
-      {
-        body: t.Object({
-          strategy: t.Optional(literalUnion(POOL_ROUTING_STRATEGIES)),
-          rotateCount: t.Optional(t.Number()),
-        }),
-      },
-      async ({ request, body }) => {
-        return await factory.updateStrategy(
-          config.accessResolver(request),
-          body as Partial<PoolStrategySetting>,
-        );
-},
-    ) as unknown as Elysia;
-}
+// Network-pool control-plane HTTP routes. The only module that touches Elysia.
+import { Elysia, t } from "elysia";
+import { consoleErrorHandler } from "../../shared/errors";
+import { literalUnion } from "../../shared/elysia-schema";
+import { RELAY_TARGETS, type RelayDeployRequest } from "./relay-deploy";
+import { RELAY_REGIONS } from "./relay-regions";
+import { SPEED_TEST_DEFAULT_BYTES } from "./speed-test-sizes";
+import {
+  MAX_BATCH_PROBE_TARGETS,
+  POOL_KINDS,
+  POOL_ROUTING_STRATEGIES,
+  POOL_STATUSES,
+  type CreateNetworkPoolRequest,
+  type NetworkPoolConfig,
+  type PoolStrategySetting,
+} from "./contracts";
+import { createNetworkPoolOperations } from "./operations";
+import { parseProxyFile } from "./import-parse";
+
+const poolKindSchema = literalUnion(POOL_KINDS);
+const createPoolBody = t.Object({
+  kind: poolKindSchema,
+  label: t.Optional(t.String()),
+  endpoint: t.String(),
+  credential: t.Optional(t.String()),
+  maxInflight: t.Optional(t.Number()),
+  weight: t.Optional(t.Number()),
+  status: t.Optional(literalUnion(POOL_STATUSES)),
+  config: t.Optional(t.Record(t.String(), t.Unknown())),
+  /** Egress allowance in bytes; `null` clears it back to unmetered. */
+  quotaBytes: t.Optional(t.Union([t.Number({ minimum: 1 }), t.Null()])),
+  /** Operator-set family/tag naming which family this node belongs to. */
+  family: t.Optional(t.Union([t.String(), t.Null()])),
+});
+const deployRelayBody = t.Object({
+  target: literalUnion(RELAY_TARGETS),
+  token: t.String({ minLength: 1 }),
+  accountId: t.Optional(t.String()),
+  projectName: t.Optional(t.String()),
+  /** Vercel function region; ignored for targets that have no region control. */
+  region: t.Optional(literalUnion(RELAY_REGIONS)),
+});
+const testBatchBody = t.Object({
+  targets: t.Array(createPoolBody, { minItems: 1, maxItems: MAX_BATCH_PROBE_TARGETS }),
+});
+const updatePoolBody = t.Partial(createPoolBody);
+/**
+ * A pasted proxy list. `content` is the file's text; the shapes accepted are
+ * documented on {@link parseProxyFile}. `maxInflight` and `weight` apply to
+ * every imported row, because a file carries no per-row tuning.
+ */
+const importPoolsBody = t.Object({
+  content: t.String({ minLength: 1 }),
+  maxInflight: t.Optional(t.Number()),
+  weight: t.Optional(t.Number()),
+  family: t.Optional(t.Union([t.String(), t.Null()])),
+  labelPrefix: t.Optional(t.String()),
+});
+export function createNetworkPoolRoutes(config: NetworkPoolConfig): Elysia {
+  const factory = createNetworkPoolOperations(config);
+  return new Elysia({ prefix: "/network/pools" })
+    .error(consoleErrorHandler("Network pool operation failed"))
+    .get("/", async ({ request }) => {
+      return await factory.listPools(config.accessResolver(request));
+})
+    .get("/:poolId", async ({ request, params }) => {
+      return await factory.getPoolDetail(config.accessResolver(request), params.poolId);
+})
+    .post("/", { body: createPoolBody }, async ({ request, body, set }) => {
+      set.status = 201;
+      return await factory.createPool(
+        config.accessResolver(request),
+        body as CreateNetworkPoolRequest,
+      );
+})
+    .post("/import", { body: importPoolsBody }, async ({ request, body, set }) => {
+      set.status = 200;
+      return await factory.importPools(config.accessResolver(request), body);
+    })
+    .patch("/:poolId", { body: updatePoolBody }, async ({ request, params, body }) => {
+      return await factory.updatePool(
+        config.accessResolver(request),
+        params.poolId,
+        body as Partial<CreateNetworkPoolRequest>,
+      );
+})
+    .delete("/:poolId", async ({ request, params }) => {
+      return await factory.deletePool(config.accessResolver(request), params.poolId);
+})
+    .get("/:poolId/health-events", async ({ request, params }) => {
+      return await factory.listPoolHealthEvents(config.accessResolver(request), params.poolId);
+})
+    .post("/:poolId/recover", async ({ request, params }) => {
+      return await factory.recoverPool(config.accessResolver(request), params.poolId);
+})
+    .post(
+      "/:poolId/provider-probe",
+      { body: t.Object({ providerId: t.String() }) },
+      async ({ request, params, body }) => {
+        return await factory.providerProbe(
+          config.accessResolver(request),
+          params.poolId,
+          body.providerId,
+        );
+      },
+    )
+    .post("/:poolId/health-check", async ({ request, params }) => {
+      return await factory.healthCheck(config.accessResolver(request), params.poolId);
+})
+    .post(
+      "/:poolId/speed-test",
+      { body: t.Optional(t.Object({ bytes: t.Optional(t.Number()) })) },
+      async ({ request, params, body }) => {
+        return await factory.speedTest(
+          config.accessResolver(request),
+          params.poolId,
+          body?.bytes ?? SPEED_TEST_DEFAULT_BYTES,
+        );
+      },
+    )
+    .post("/test", { body: createPoolBody }, async ({ request, body }) => {
+      return await factory.probeAdHocPool(
+        config.accessResolver(request),
+        body as CreateNetworkPoolRequest,
+      );
+})
+    .post("/test-batch", { body: testBatchBody }, async ({ request, body }) => {
+      return await factory.probeAdHocPoolBatch(
+        config.accessResolver(request),
+        body.targets as CreateNetworkPoolRequest[],
+      );
+})
+    .post(
+      "/test-batch/provider",
+      {
+        body: t.Object({
+          providerId: t.String(),
+          targets: t.Array(createPoolBody, { minItems: 1, maxItems: MAX_BATCH_PROBE_TARGETS }),
+        }),
+      },
+      async ({ request, body }) => {
+        return await factory.probeAdHocProviderBatch(
+          config.accessResolver(request),
+          body.targets as CreateNetworkPoolRequest[],
+          body.providerId,
+        );
+      },
+    )
+    .post(
+      "/:poolId/cooldowns/clear",
+      { body: t.Optional(t.Object({ providerId: t.Optional(t.String()) })) },
+      async ({ request, params, body }) => {
+        return await factory.clearPoolCooldown(
+          config.accessResolver(request),
+          params.poolId,
+          body?.providerId,
+        );
+},
+    )
+    .post("/relay/deploy", { body: deployRelayBody }, async ({ request, body }) => {
+      return await factory.deployRelay(config.accessResolver(request), body as RelayDeployRequest);
+    })
+    .get("/strategy", async ({ request }) => {
+      return await factory.getStrategy(config.accessResolver(request));
+})
+    .patch(
+      "/strategy",
+      {
+        body: t.Object({
+          strategy: t.Optional(literalUnion(POOL_ROUTING_STRATEGIES)),
+          rotateCount: t.Optional(t.Number()),
+        }),
+      },
+      async ({ request, body }) => {
+        return await factory.updateStrategy(
+          config.accessResolver(request),
+          body as Partial<PoolStrategySetting>,
+        );
+},
+    ) as unknown as Elysia;
+}