@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/lib/providerTestPrompt.ts

@@ -1,100 +0,0 @@
-export type ProviderTestMode = "non-streaming" | "streaming";
-export type ProviderTestApiShape = "chat" | "responses";
-
-export type ProviderTestMessage = {
-  role: "user";
-  content: string;
-};
-
-export type ProviderTestChatRequestBody = {
-  model: string;
-  messages: ProviderTestMessage[];
-  max_tokens: number;
-  stream: boolean;
-};
-
-export type ProviderTestResponsesRequestBody = {
-  model: string;
-  input: string;
-  max_output_tokens: number;
-  stream: boolean;
-};
-
-export type ProviderTestRequestBody =
-  | ProviderTestChatRequestBody
-  | ProviderTestResponsesRequestBody;
-
-const MEMORY_PROBE_FACTS = [
-  "Project fact: Agent Inspector captures LLM traffic and turns it into Raw Trace, Session Episode, and Memory Candidate layers.",
-  "Procedure: before release, run bun test, npm run typecheck, npm run lint, npm run build, and openspec validate --all --strict.",
-  "Preference: the user prefers Chinese summaries, explicit verification, and commit/push/release closure when requested.",
-  "Pitfall: preserve .llm-inspector config compatibility; do not write raw logs or secrets into durable memory.",
-  "OpenClaw boundary: Agent Inspector owns L1-L3; OpenClaw owns durable indexing, retrieval, and recall.",
-];
-
-function modeInstruction(mode: ProviderTestMode): string {
-  switch (mode) {
-    case "non-streaming":
-      return "Reply in four concise bullets.";
-    case "streaming":
-      return "Reply in three concise bullets.";
-  }
-}
-
-function maxTokensForMode(mode: ProviderTestMode): number {
-  switch (mode) {
-    case "non-streaming":
-      return 256;
-    case "streaming":
-      return 256;
-  }
-}
-
-export function buildProviderTestUserPrompt(mode: ProviderTestMode): string {
-  return [
-    "You are validating an LLM provider connection for Agent Inspector.",
-    "This request includes a synthetic memory probe so Agent Inspector can verify its three Inspector-owned memory layers.",
-    "",
-    "Synthetic memory probe:",
-    ...MEMORY_PROBE_FACTS.map((fact) => `- ${fact}`),
-    "",
-    "Return:",
-    "1. connection status",
-    "2. one project fact",
-    "3. one reusable procedure",
-    "4. one caution",
-    "",
-    modeInstruction(mode),
-  ].join("\n");
-}
-
-export function buildProviderTestMessages(mode: ProviderTestMode): ProviderTestMessage[] {
-  return [{ role: "user", content: buildProviderTestUserPrompt(mode) }];
-}
-
-export function buildProviderTestRequestBody(
-  model: string,
-  mode: ProviderTestMode,
-  apiShape: ProviderTestApiShape = "chat",
-): ProviderTestRequestBody {
-  if (apiShape === "responses") {
-    return {
-      model,
-      input: buildProviderTestUserPrompt(mode),
-      max_output_tokens: maxTokensForMode(mode),
-      stream: mode === "streaming",
-    };
-  }
-
-  const base = {
-    model,
-    messages: buildProviderTestMessages(mode),
-    max_tokens: maxTokensForMode(mode),
-  };
-  switch (mode) {
-    case "non-streaming":
-      return { ...base, stream: false };
-    case "streaming":
-      return { ...base, stream: true };
-  }
-}

package/src/lib/publicBasePathContext.ts

@@ -1,137 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import {
-  AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER,
-  AGENT_INSPECTOR_PUBLIC_ORIGIN_HEADER,
-  AGENT_INSPECTOR_PUBLIC_PORT_HEADER,
-  getConfiguredBasePath,
-  normalizePublicBasePath,
-} from "./basePath";
-import { getCurrentPort } from "./serverPort";
-
-type BasePathEnv = Readonly<Record<string, string | undefined>>;
-
-type PublicRequestContext = {
-  basePath: string;
-  publicOrigin: string | null;
-  publicPort: number | null;
-};
-
-const publicRequestStorage = new AsyncLocalStorage<PublicRequestContext>();
-
-/**
- * Resolve the public Base Path attached by the trusted ingress. Invalid or
- * missing values fall back to the process's canonical Base Path.
- */
-export function resolveRequestPublicBasePath(request: Request, env?: BasePathEnv): string {
-  const rawValue = request.headers.get(AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER);
-  if (rawValue !== null) {
-    const normalized = normalizePublicBasePath(rawValue);
-    if (normalized !== null) return normalized;
-  }
-  return getConfiguredBasePath(env ?? process.env);
-}
-
-/** Resolve the trusted ingress listener port without consulting request URL or Host. */
-export function resolveRequestPublicPort(request: Request): number | null {
-  const rawValue = request.headers.get(AGENT_INSPECTOR_PUBLIC_PORT_HEADER);
-  if (rawValue !== null && /^\d{1,5}$/u.test(rawValue)) {
-    const headerPort = Number(rawValue);
-    if (Number.isSafeInteger(headerPort) && headerPort > 0 && headerPort <= 65_535) {
-      return headerPort;
-    }
-  }
-  try {
-    return getCurrentPort();
-  } catch {
-    // Vite dev does not always publish its listener port through process env.
-  }
-  try {
-    const urlPort = new URL(request.url).port;
-    if (!/^\d{1,5}$/u.test(urlPort)) return null;
-    const port = Number(urlPort);
-    return Number.isSafeInteger(port) && port > 0 && port <= 65_535 ? port : null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizedPublicOrigin(value: string): string | null {
-  try {
-    const parsed = new URL(value);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
-    if (parsed.username.length > 0 || parsed.password.length > 0) return null;
-    if (parsed.pathname !== "/" || parsed.search.length > 0 || parsed.hash.length > 0) return null;
-    return parsed.origin;
-  } catch {
-    return null;
-  }
-}
-
-/** Resolve the public origin set by trusted ingress without consulting forwarded headers. */
-export function resolveRequestPublicOrigin(request: Request): string | null {
-  const headerOrigin = request.headers.get(AGENT_INSPECTOR_PUBLIC_ORIGIN_HEADER);
-  if (headerOrigin !== null) return normalizedPublicOrigin(headerOrigin);
-  try {
-    return normalizedPublicOrigin(new URL(request.url).origin);
-  } catch {
-    return null;
-  }
-}
-
-/** Return the originating request's public Base Path, or the canonical path outside a request. */
-export function getPublicBasePath(env?: BasePathEnv): string {
-  return publicRequestStorage.getStore()?.basePath ?? getConfiguredBasePath(env ?? process.env);
-}
-
-/** Return the trusted ingress listener port, or the canonical process port outside a request. */
-export function getPublicPort(): number {
-  return publicRequestStorage.getStore()?.publicPort ?? getCurrentPort();
-}
-
-/** Return the trusted public origin, with a loopback fallback outside an ingress request. */
-export function getPublicOrigin(): string {
-  return (
-    publicRequestStorage.getStore()?.publicOrigin ?? `http://localhost:${String(getCurrentPort())}`
-  );
-}
-
-/** Run work with an explicitly selected public Base Path. Primarily useful for internal calls. */
-export function runWithPublicBasePath<T>(basePath: string, callback: () => T): T {
-  const current = publicRequestStorage.getStore();
-  const normalized = normalizePublicBasePath(basePath) ?? getConfiguredBasePath(process.env);
-  return publicRequestStorage.run(
-    {
-      basePath: normalized,
-      publicOrigin: current?.publicOrigin ?? null,
-      publicPort: current?.publicPort ?? null,
-    },
-    callback,
-  );
-}
-
-/** Run work with an explicit trusted public listener port. */
-export function runWithPublicPort<T>(publicPort: number, callback: () => T): T {
-  const current = publicRequestStorage.getStore();
-  const normalizedPort =
-    Number.isSafeInteger(publicPort) && publicPort > 0 && publicPort <= 65_535 ? publicPort : null;
-  return publicRequestStorage.run(
-    {
-      basePath: current?.basePath ?? getConfiguredBasePath(process.env),
-      publicOrigin: current?.publicOrigin ?? null,
-      publicPort: normalizedPort,
-    },
-    callback,
-  );
-}
-
-/** Run the complete request chain with the ingress-selected public Base Path. */
-export function runWithRequestPublicBasePath<T>(request: Request, callback: () => T): T {
-  return publicRequestStorage.run(
-    {
-      basePath: resolveRequestPublicBasePath(request),
-      publicOrigin: resolveRequestPublicOrigin(request),
-      publicPort: resolveRequestPublicPort(request),
-    },
-    callback,
-  );
-}

package/src/lib/resourceLimits.ts

@@ -1,345 +0,0 @@
-import { z } from "zod";
-
-export const MAX_REST_LOG_PAGE_SIZE = 200;
-export const MAX_SEARCH_QUERY_CHARS = 512;
-export const MAX_SEARCH_PROJECT_CHARS = 256;
-export const MAX_PROVIDER_MODELS = 64;
-export const MAX_PROVIDER_MODEL_NAME_CHARS = 256;
-export const MAX_PROVIDER_MODEL_METADATA = 64;
-export const MAX_SSE_CLIENTS = 32;
-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",
-  "provider-model-limit-exceeded",
-  "sse-capacity-exceeded",
-  "provider-test-capacity-exceeded",
-  "proxy-capacity-exceeded",
-]);
-
-export const ResourceLimitStatusSchema = z.union([
-  z.literal(400),
-  z.literal(413),
-  z.literal(429),
-  z.literal(503),
-]);
-
-export const ResourceLimitErrorSchema = z.object({
-  error: z.string().min(1).max(300),
-  code: ResourceLimitErrorCodeSchema,
-  status: ResourceLimitStatusSchema,
-  resource: z.string().min(1).max(80),
-  limit: z.number().int().positive(),
-  retryable: z.boolean(),
-});
-
-export type ResourceLimitErrorCode = z.infer<typeof ResourceLimitErrorCodeSchema>;
-export type ResourceLimitStatus = z.infer<typeof ResourceLimitStatusSchema>;
-export type ResourceLimitError = z.infer<typeof ResourceLimitErrorSchema>;
-
-export type ResourceLimitErrorInput = {
-  error: string;
-  code: ResourceLimitErrorCode;
-  status: ResourceLimitStatus;
-  resource: string;
-  limit: number;
-  retryable: boolean;
-};
-
-export function createResourceLimitError(input: ResourceLimitErrorInput): ResourceLimitError {
-  return ResourceLimitErrorSchema.parse(input);
-}
-
-export function resourceLimitResponse(
-  input: ResourceLimitErrorInput & { retryAfterSeconds?: number },
-): Response {
-  const body = createResourceLimitError(input);
-  const headers = new Headers({ "cache-control": "no-store" });
-  if (input.retryAfterSeconds !== undefined) {
-    headers.set("retry-after", String(input.retryAfterSeconds));
-  }
-  return Response.json(body, { status: input.status, headers });
-}
-
-type BoundedIntegerParameterInput = {
-  value: string | null;
-  parameter: string;
-  fallback: number;
-  minimum: number;
-  maximum: number;
-  resource: string;
-};
-
-export type BoundedIntegerParameterResult =
-  | { ok: true; value: number }
-  | { ok: false; response: Response };
-
-export function parseBoundedIntegerParameter(
-  input: BoundedIntegerParameterInput,
-): BoundedIntegerParameterResult {
-  if (input.value === null) return { ok: true, value: input.fallback };
-
-  const parsed = Number(input.value);
-  if (!Number.isSafeInteger(parsed) || parsed < input.minimum || parsed > input.maximum) {
-    return {
-      ok: false,
-      response: resourceLimitResponse({
-        error: `Query parameter "${input.parameter}" must be an integer between ${String(input.minimum)} and ${String(input.maximum)}.`,
-        code: "invalid-page-request",
-        status: 400,
-        resource: input.resource,
-        limit: input.maximum,
-        retryable: false,
-      }),
-    };
-  }
-
-  return { ok: true, value: parsed };
-}
-
-export type CapacityLease = {
-  release: () => void;
-};
-
-export type CapacityLimiter = {
-  tryAcquire: () => CapacityLease | null;
-  activeCount: () => number;
-  capacity: number;
-};
-
-export function createCapacityLimiter(maxActive: number): CapacityLimiter {
-  const capacity = Number.isSafeInteger(maxActive) && maxActive > 0 ? maxActive : 1;
-  let active = 0;
-
-  return {
-    capacity,
-    activeCount: () => active,
-    tryAcquire: () => {
-      if (active >= capacity) return null;
-      active += 1;
-      let released = false;
-      return {
-        release: () => {
-          if (released) return;
-          released = true;
-          active = Math.max(0, active - 1);
-        },
-      };
-    },
-  };
-}
-
-export async function runWithConcurrencyLimit(
-  tasks: readonly (() => Promise<void>)[],
-  maxConcurrent: number,
-): Promise<void> {
-  if (tasks.length === 0) return;
-  const concurrency = Number.isSafeInteger(maxConcurrent) && maxConcurrent > 0 ? maxConcurrent : 1;
-  const workerCount = Math.min(concurrency, tasks.length);
-  let nextIndex = 0;
-
-  const runWorker = async (): Promise<void> => {
-    while (nextIndex < tasks.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const task = tasks[index];
-      if (task !== undefined) await task();
-    }
-  };
-
-  await Promise.all(Array.from({ length: workerCount }, runWorker));
-}