@tonyclaw/agent-inspector 3.1.19 → 3.1.21

package/src/knowledge/openclawClient.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../lib/resourceLimits";
 import { safeFetch } from "../lib/safeFetch";
 import type { KnowledgeCandidate, KnowledgeSearchResponse, OpenClawMemoryPayload } from "./types";
 import { KnowledgeSearchResponseSchema, KnowledgeSearchResultSchema } from "./types";
@@ -89,7 +90,11 @@ export async function promoteToOpenClaw(candidate: KnowledgeCandidate): Promise<
       headers: authHeaders(),
       body: JSON.stringify(buildOpenClawPayload(candidate)),
     },
-    { bypass: true },
+    {
+      bypass: true,
+      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
+      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
+    },
   );
   if (!fetchResult.ok) return { success: false, error: fetchResult.reason };
   const response = fetchResult.response;
@@ -133,7 +138,11 @@ export async function searchOpenClaw(
       method: "GET",
       headers: authHeaders(),
     },
-    { bypass: true },
+    {
+      bypass: true,
+      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
+      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
+    },
   );
   if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
   const response = fetchResult.response;

package/src/knowledge/openclawGatewayClient.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../lib/resourceLimits";
 import { safeFetch } from "../lib/safeFetch";
 import type { KnowledgeSearchResponse, KnowledgeSearchResult } from "./types";
 
@@ -208,7 +209,11 @@ export async function searchOpenClawGateway(
         sessionKey: getOpenClawSessionKey(),
       }),
     },
-    { bypass: true },
+    {
+      bypass: true,
+      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
+      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
+    },
   );
   if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
   const response = fetchResult.response;

package/src/lib/resourceLimits.ts

@@ -11,6 +11,197 @@ export const MAX_ACTIVE_PROVIDER_TESTS = 2;
 export const MAX_PROVIDER_TEST_CONCURRENCY = 4;
 export const MAX_ACTIVE_PROXY_REQUESTS = 16;
 
+const positiveInteger = z.number().int().positive();
+
+export const RuntimeBudgetPolicySchema = z
+  .object({
+    proxy: z.object({
+      requestBytes: positiveInteger,
+      responseBytes: positiveInteger,
+      headerBytes: positiveInteger,
+      deadlineMs: positiveInteger,
+      idleTimeoutMs: positiveInteger,
+      activeRequests: positiveInteger,
+    }),
+    control: z.object({
+      requestBytes: positiveInteger,
+      responseBytes: positiveInteger,
+      headerBytes: positiveInteger,
+      deadlineMs: positiveInteger,
+      idleTimeoutMs: positiveInteger,
+      activeRequests: positiveInteger,
+    }),
+    upstream: z.object({
+      fetchResponseBytes: positiveInteger,
+      fetchDeadlineMs: positiveInteger,
+      replayResponseBytes: positiveInteger,
+      replayDeadlineMs: positiveInteger,
+      metadataResponseBytes: positiveInteger,
+      metadataDeadlineMs: positiveInteger,
+      connectTimeoutMs: positiveInteger,
+      idleTimeoutMs: positiveInteger,
+    }),
+    pagination: z.object({
+      restPageSize: positiveInteger,
+      searchQueryChars: positiveInteger,
+      searchProjectChars: positiveInteger,
+    }),
+    sse: z.object({
+      clients: positiveInteger,
+      initLogs: positiveInteger,
+      heartbeatMs: positiveInteger,
+    }),
+    imports: z.object({
+      archiveBytes: positiveInteger,
+      entries: positiveInteger,
+      entryBytes: positiveInteger,
+      uncompressedBytes: positiveInteger,
+      expansionRatio: positiveInteger,
+    }),
+    fanOut: z.object({
+      providerModels: positiveInteger,
+      providerModelMetadata: positiveInteger,
+      providerTestConcurrency: positiveInteger,
+      activeProviderTests: positiveInteger,
+    }),
+    queues: z.object({
+      proxyRequests: positiveInteger,
+      finalizerJobs: positiveInteger,
+      rawStreamMessages: positiveInteger,
+      rawStreamBytes: positiveInteger,
+      backgroundWorkers: positiveInteger,
+    }),
+  })
+  .superRefine((policy, context) => {
+    if (policy.control.requestBytes > policy.proxy.requestBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["control", "requestBytes"],
+        message: "control request budget must not exceed proxy request budget",
+      });
+    }
+    if (policy.control.responseBytes > policy.proxy.responseBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["control", "responseBytes"],
+        message: "control response budget must not exceed proxy response budget",
+      });
+    }
+    if (policy.control.activeRequests > policy.proxy.activeRequests) {
+      context.addIssue({
+        code: "custom",
+        path: ["control", "activeRequests"],
+        message: "control active request budget must not exceed proxy active request budget",
+      });
+    }
+    if (policy.upstream.fetchResponseBytes > policy.proxy.responseBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["upstream", "fetchResponseBytes"],
+        message: "upstream fetch response budget must not exceed proxy response budget",
+      });
+    }
+    if (policy.upstream.replayResponseBytes > policy.proxy.responseBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["upstream", "replayResponseBytes"],
+        message: "upstream replay response budget must not exceed proxy response budget",
+      });
+    }
+    if (policy.upstream.metadataResponseBytes > policy.control.responseBytes) {
+      context.addIssue({
+        code: "custom",
+        path: ["upstream", "metadataResponseBytes"],
+        message: "upstream metadata response budget must not exceed control response budget",
+      });
+    }
+    if (policy.upstream.metadataDeadlineMs > policy.control.deadlineMs) {
+      context.addIssue({
+        code: "custom",
+        path: ["upstream", "metadataDeadlineMs"],
+        message: "upstream metadata deadline must not exceed control deadline",
+      });
+    }
+    if (policy.queues.proxyRequests < policy.proxy.activeRequests) {
+      context.addIssue({
+        code: "custom",
+        path: ["queues", "proxyRequests"],
+        message: "proxy request queue budget must cover active proxy requests",
+      });
+    }
+  });
+
+export type RuntimeBudgetPolicy = z.infer<typeof RuntimeBudgetPolicySchema>;
+
+export const DEFAULT_RUNTIME_BUDGET_POLICY = RuntimeBudgetPolicySchema.parse({
+  proxy: {
+    requestBytes: 64 * 1024 * 1024,
+    responseBytes: 256 * 1024 * 1024,
+    headerBytes: 64 * 1024,
+    deadlineMs: 120_000,
+    idleTimeoutMs: 30_000,
+    activeRequests: MAX_ACTIVE_PROXY_REQUESTS,
+  },
+  control: {
+    requestBytes: 8 * 1024 * 1024,
+    responseBytes: 64 * 1024 * 1024,
+    headerBytes: 32 * 1024,
+    deadlineMs: 30_000,
+    idleTimeoutMs: 10_000,
+    activeRequests: 8,
+  },
+  upstream: {
+    fetchResponseBytes: 256 * 1024 * 1024,
+    fetchDeadlineMs: 120_000,
+    replayResponseBytes: 256 * 1024 * 1024,
+    replayDeadlineMs: 120_000,
+    metadataResponseBytes: 10 * 1024 * 1024,
+    metadataDeadlineMs: 30_000,
+    connectTimeoutMs: 10_000,
+    idleTimeoutMs: 30_000,
+  },
+  pagination: {
+    restPageSize: MAX_REST_LOG_PAGE_SIZE,
+    searchQueryChars: MAX_SEARCH_QUERY_CHARS,
+    searchProjectChars: MAX_SEARCH_PROJECT_CHARS,
+  },
+  sse: {
+    clients: MAX_SSE_CLIENTS,
+    initLogs: 500,
+    heartbeatMs: 15_000,
+  },
+  imports: {
+    archiveBytes: 64 * 1024 * 1024,
+    entries: 5_000,
+    entryBytes: 32 * 1024 * 1024,
+    uncompressedBytes: 256 * 1024 * 1024,
+    expansionRatio: 20,
+  },
+  fanOut: {
+    providerModels: MAX_PROVIDER_MODELS,
+    providerModelMetadata: MAX_PROVIDER_MODEL_METADATA,
+    providerTestConcurrency: MAX_PROVIDER_TEST_CONCURRENCY,
+    activeProviderTests: MAX_ACTIVE_PROVIDER_TESTS,
+  },
+  queues: {
+    proxyRequests: MAX_ACTIVE_PROXY_REQUESTS,
+    finalizerJobs: 1_000,
+    rawStreamMessages: 16_384,
+    rawStreamBytes: 64 * 1024 * 1024,
+    backgroundWorkers: 4,
+  },
+});
+
+export function validateRuntimeBudgetPolicy(input: unknown): RuntimeBudgetPolicy {
+  return RuntimeBudgetPolicySchema.parse(input);
+}
+
+export function runtimeBudgetPolicySnapshot(
+  policy: RuntimeBudgetPolicy = DEFAULT_RUNTIME_BUDGET_POLICY,
+): RuntimeBudgetPolicy {
+  return RuntimeBudgetPolicySchema.parse(policy);
+}
+
 export const ResourceLimitErrorCodeSchema = z.enum([
   "invalid-page-request",
   "search-limit-exceeded",