@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/lib/instanceContract.ts

@@ -1,239 +0,0 @@
-import { z } from "zod";
-import { BackendImplementationSchema } from "./backendImplementation";
-import { normalizePublicBasePath } from "./basePath";
-
-export const INSTANCE_API_SCHEMA_VERSION = 1;
-
-function isCanonicalPublicBasePath(value: string): boolean {
-  const normalized = normalizePublicBasePath(value);
-  return normalized !== null && (normalized.length === 0 ? "/" : normalized) === value;
-}
-
-export const InstanceStateSchema = z.enum(["running", "stopped", "conflict"]);
-export const InstanceStateReasonSchema = z.enum(["identity_mismatch", "port_conflict"]);
-
-export const InstanceUrlsSchema = z
-  .object({
-    ui: z.url(),
-    api: z.url(),
-    health: z.url(),
-    proxy: z.url(),
-    openai: z.url(),
-    mcp: z.url(),
-  })
-  .strict();
-
-export const InstanceStatusOutputSchema = z
-  .object({
-    schemaVersion: z.literal(INSTANCE_API_SCHEMA_VERSION),
-    name: z.string().min(1),
-    instanceId: z.string().min(1),
-    state: InstanceStateSchema,
-    stateReason: InstanceStateReasonSchema.nullable(),
-    checkedAt: z.iso.datetime(),
-    createdAt: z.iso.datetime(),
-    updatedAt: z.iso.datetime(),
-    launch: z
-      .object({
-        launchId: z.string().min(1),
-        startedAt: z.iso.datetime(),
-      })
-      .strict(),
-    host: z.string().min(1),
-    publicPort: z.number().int().min(1).max(65_535),
-    upstreamPort: z.number().int().min(1).max(65_535),
-    basePath: z.string().refine(isCanonicalPublicBasePath, "Invalid public Base Path"),
-    captureMode: z.enum(["simple", "full"]),
-    backend: BackendImplementationSchema.default("typescript"),
-    uiEnabled: z.boolean(),
-    dataDir: z.string().min(1),
-    supervisorPid: z.number().int().positive().nullable(),
-    urls: InstanceUrlsSchema,
-  })
-  .strict();
-
-export const InstanceConnectionSurfacesSchema = z
-  .object({
-    ui: z
-      .object({
-        enabled: z.boolean(),
-        baseUrl: z.url().nullable(),
-      })
-      .strict(),
-    control: z.object({ baseUrl: z.url() }).strict(),
-    agent: z.object({ baseUrl: z.url() }).strict(),
-  })
-  .strict();
-
-export const InstanceConnectionOutputSchema = z
-  .object({
-    schemaVersion: z.literal(INSTANCE_API_SCHEMA_VERSION),
-    uiEnabled: z.boolean(),
-    instance: InstanceStatusOutputSchema,
-    surfaces: InstanceConnectionSurfacesSchema,
-    /** @deprecated Use surfaces.control.baseUrl or surfaces.agent.baseUrl. */
-    baseUrl: z.url(),
-    endpoints: InstanceUrlsSchema,
-    environment: z
-      .object({
-        ANTHROPIC_BASE_URL: z.url(),
-        LLM_BASE_URL: z.url(),
-        OPENAI_BASE_URL: z.url(),
-        AGENT_INSPECTOR_MCP_URL: z.url(),
-      })
-      .strict(),
-    mcp: z
-      .object({
-        serverName: z.string().min(1),
-        transport: z.literal("streamable-http"),
-        url: z.url(),
-      })
-      .strict(),
-    codex: z
-      .object({
-        providerName: z.string().min(1),
-        baseUrl: z.url(),
-        wireApi: z.literal("responses"),
-      })
-      .strict(),
-  })
-  .strict();
-
-export const InstanceStartRequestSchema = z
-  .object({
-    port: z.number().int().min(1).max(65_535).optional(),
-    basePath: z
-      .string()
-      .min(1)
-      .max(2_048)
-      .refine(
-        (value) => normalizePublicBasePath(value) !== null,
-        "Base Path must use URL-safe path segments without traversal, encoded separators, or markup characters",
-      )
-      .optional(),
-    host: z
-      .string()
-      .min(1)
-      .max(253)
-      .refine(
-        (value) =>
-          value.trim() === value &&
-          !value.includes("://") &&
-          !value.includes("/") &&
-          !value.includes("\\") &&
-          !/\s/u.test(value),
-        "Host must be a hostname or IP address without protocol, path, or whitespace",
-      )
-      .optional(),
-    captureMode: z.enum(["simple", "full"]).optional(),
-    backend: BackendImplementationSchema.optional(),
-    uiEnabled: z.boolean().optional(),
-    dataDir: z.string().trim().min(1).max(32_767).optional(),
-  })
-  .strict();
-
-export const InstanceEmptyRequestSchema = z.object({}).strict();
-
-export const InstanceOperationSchema = z.enum(["start", "stop", "restart"]);
-export const InstanceOperationOutcomeSchema = z.enum([
-  "created",
-  "started",
-  "already_running",
-  "stopped",
-  "already_stopped",
-  "restarted",
-]);
-
-export const InstanceOperationOutputSchema = z
-  .object({
-    schemaVersion: z.literal(INSTANCE_API_SCHEMA_VERSION),
-    operation: InstanceOperationSchema,
-    outcome: InstanceOperationOutcomeSchema,
-    instance: InstanceStatusOutputSchema,
-  })
-  .strict();
-
-export const InstanceListOutputSchema = z
-  .object({
-    schemaVersion: z.literal(INSTANCE_API_SCHEMA_VERSION),
-    instances: z.array(InstanceStatusOutputSchema),
-  })
-  .strict();
-
-export const InstancePublicErrorCodeSchema = z.enum([
-  "argument_invalid",
-  "config_mismatch",
-  "data_dir_conflict",
-  "data_dir_invalid",
-  "identity_mismatch",
-  "instance_not_found",
-  "launch_failed",
-  "launch_unavailable",
-  "lock_not_owned",
-  "lock_timeout",
-  "name_invalid",
-  "port_conflict",
-  "port_exhausted",
-  "port_invalid",
-  "record_invalid",
-  "registry_io",
-  "restart_failed_degraded",
-  "restart_failed_rolled_back",
-  "self_lifecycle_unsupported",
-  "shutdown_failed",
-]);
-
-export const InstancePublicErrorSchema = z
-  .object({
-    code: InstancePublicErrorCodeSchema,
-    message: z.string().min(1),
-    retryable: z.boolean(),
-  })
-  .strict();
-
-export const InstanceErrorOutputSchema = z
-  .object({
-    schemaVersion: z.literal(INSTANCE_API_SCHEMA_VERSION),
-    error: InstancePublicErrorSchema,
-  })
-  .strict();
-
-export type InstanceStatusOutput = z.infer<typeof InstanceStatusOutputSchema>;
-export type InstanceConnectionOutput = z.infer<typeof InstanceConnectionOutputSchema>;
-export type InstanceStartRequest = z.infer<typeof InstanceStartRequestSchema>;
-export type InstanceOperationOutcome = z.infer<typeof InstanceOperationOutcomeSchema>;
-export type InstanceOperationOutput = z.infer<typeof InstanceOperationOutputSchema>;
-export type InstancePublicErrorCode = z.infer<typeof InstancePublicErrorCodeSchema>;
-export type InstancePublicError = z.infer<typeof InstancePublicErrorSchema>;
-export type InstanceErrorOutput = z.infer<typeof InstanceErrorOutputSchema>;
-
-export function isRetryableInstanceError(code: InstancePublicErrorCode): boolean {
-  switch (code) {
-    case "launch_failed":
-    case "launch_unavailable":
-    case "lock_timeout":
-    case "port_exhausted":
-    case "registry_io":
-    case "restart_failed_degraded":
-    case "restart_failed_rolled_back":
-    case "shutdown_failed":
-      return true;
-    case "argument_invalid":
-    case "config_mismatch":
-    case "data_dir_conflict":
-    case "data_dir_invalid":
-    case "identity_mismatch":
-    case "instance_not_found":
-    case "lock_not_owned":
-    case "name_invalid":
-    case "port_conflict":
-    case "port_invalid":
-    case "record_invalid":
-    case "self_lifecycle_unsupported":
-      return false;
-  }
-}
-
-export function instanceErrorOutput(error: InstancePublicError): InstanceErrorOutput {
-  return { schemaVersion: INSTANCE_API_SCHEMA_VERSION, error };
-}

package/src/lib/jsonFile.ts

@@ -1,46 +0,0 @@
-import { readFileSync } from "node:fs";
-import { z } from "zod";
-import { readProperty } from "./unknown";
-
-/**
- * Reads a UTF-8 JSON file from disk and validates it against a Zod schema in
- * one call. Used by config/secret/evidence files that store small records
- * atomically rewritten on update — *not* for streaming log files (those go
- * through line-by-line parsing in store.ts).
- *
- * On any failure returns `{ ok: false, reason }` rather than throwing. The
- * caller decides between returning a fallback, logging, or surfacing an
- * error response. To log on failure, wrap the call site with the project's
- * `logger.warn` (the helper stays a pure parser to avoid a `lib → proxy`
- * dependency direction).
- */
-export type ReadJsonFileFailureReason = "missing" | "io-error" | "parse-error" | "schema-mismatch";
-
-export type ReadJsonFileResult<T> =
-  | { ok: true; data: T }
-  | { ok: false; reason: ReadJsonFileFailureReason };
-
-export function readJsonFile<T>(path: string, schema: z.ZodType<T>): ReadJsonFileResult<T> {
-  let raw: string;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch (error) {
-    if (isEnoent(error)) return { ok: false, reason: "missing" };
-    return { ok: false, reason: "io-error" };
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { ok: false, reason: "parse-error" };
-  }
-
-  const result = schema.safeParse(parsed);
-  if (!result.success) return { ok: false, reason: "schema-mismatch" };
-  return { ok: true, data: result.data };
-}
-
-function isEnoent(error: unknown): boolean {
-  return readProperty(error, "code") === "ENOENT";
-}

package/src/lib/logImportContract.ts

@@ -1,12 +0,0 @@
-import { z } from "zod";
-import { CapturedLogSchema } from "../contracts";
-
-export const ImportLogsResponseSchema = z.object({
-  sessionId: z.string(),
-  imported: z.number().int().nonnegative(),
-  skipped: z.number().int().nonnegative(),
-  warnings: z.array(z.string()),
-  logs: z.array(CapturedLogSchema),
-});
-
-export type ImportLogsResponse = z.infer<typeof ImportLogsResponseSchema>;

package/src/lib/managedInstance.ts

@@ -1,112 +0,0 @@
-export const MANAGED_INSTANCE_CONTROL_PATH = "/.agent-inspector/instance";
-export const MANAGED_INSTANCE_SHUTDOWN_PATH = `${MANAGED_INSTANCE_CONTROL_PATH}/shutdown`;
-export const MANAGED_INSTANCE_TOKEN_HEADER = "x-agent-inspector-instance-token";
-export const MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE = "agent-inspector:managed-shutdown";
-export const AGENT_INSPECTOR_CLI_ENTRY_ENV = "AGENT_INSPECTOR_CLI_ENTRY";
-
-export const MANAGED_INSTANCE_ENV = {
-  backend: "AGENT_INSPECTOR_INSTANCE_BACKEND",
-  name: "AGENT_INSPECTOR_INSTANCE_NAME",
-  instanceId: "AGENT_INSPECTOR_INSTANCE_ID",
-  launchId: "AGENT_INSPECTOR_INSTANCE_LAUNCH_ID",
-  controlToken: "AGENT_INSPECTOR_INSTANCE_CONTROL_TOKEN",
-  startedAt: "AGENT_INSPECTOR_INSTANCE_STARTED_AT",
-  upstreamPort: "AGENT_INSPECTOR_UPSTREAM_PORT",
-} as const;
-
-type ManagedInstanceEnv = Readonly<Record<string, string | undefined>>;
-
-export type ManagedInstanceLaunch = {
-  backend: BackendImplementation;
-  name: string;
-  instanceId: string;
-  launchId: string;
-  controlToken: string;
-  startedAt: string;
-  upstreamPort: number;
-};
-
-export type ManagedInstanceLaunchResult =
-  | { kind: "unmanaged" }
-  | { kind: "invalid"; message: string }
-  | { kind: "managed"; launch: ManagedInstanceLaunch };
-
-export type ManagedInstanceShutdownMessage = {
-  type: typeof MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE;
-  controlToken: string;
-};
-
-function nonEmpty(value: string | undefined): string | null {
-  const trimmed = value?.trim();
-  return trimmed === undefined || trimmed.length === 0 ? null : trimmed;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-export function readManagedInstanceLaunch(
-  env: ManagedInstanceEnv = process.env,
-): ManagedInstanceLaunchResult {
-  const values = [
-    env[MANAGED_INSTANCE_ENV.backend],
-    env[MANAGED_INSTANCE_ENV.name],
-    env[MANAGED_INSTANCE_ENV.instanceId],
-    env[MANAGED_INSTANCE_ENV.launchId],
-    env[MANAGED_INSTANCE_ENV.controlToken],
-    env[MANAGED_INSTANCE_ENV.startedAt],
-    env[MANAGED_INSTANCE_ENV.upstreamPort],
-  ];
-  if (values.every((value) => value === undefined || value.trim().length === 0)) {
-    return { kind: "unmanaged" };
-  }
-
-  const name = nonEmpty(env[MANAGED_INSTANCE_ENV.name]);
-  const backend = parseBackendImplementation(
-    nonEmpty(env[MANAGED_INSTANCE_ENV.backend]) ?? undefined,
-  );
-  const instanceId = nonEmpty(env[MANAGED_INSTANCE_ENV.instanceId]);
-  const launchId = nonEmpty(env[MANAGED_INSTANCE_ENV.launchId]);
-  const controlToken = nonEmpty(env[MANAGED_INSTANCE_ENV.controlToken]);
-  const startedAt = nonEmpty(env[MANAGED_INSTANCE_ENV.startedAt]);
-  const upstreamPort = Number(env[MANAGED_INSTANCE_ENV.upstreamPort]);
-  if (
-    name === null ||
-    backend === null ||
-    instanceId === null ||
-    launchId === null ||
-    controlToken === null ||
-    controlToken.length < 32 ||
-    startedAt === null ||
-    !Number.isFinite(Date.parse(startedAt)) ||
-    !Number.isInteger(upstreamPort) ||
-    upstreamPort < 1 ||
-    upstreamPort > 65_535
-  ) {
-    return {
-      kind: "invalid",
-      message: "Managed instance launch environment is incomplete or invalid.",
-    };
-  }
-  return {
-    kind: "managed",
-    launch: { backend, name, instanceId, launchId, controlToken, startedAt, upstreamPort },
-  };
-}
-
-export function managedInstanceShutdownMessage(
-  controlToken: string,
-): ManagedInstanceShutdownMessage {
-  return { type: MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE, controlToken };
-}
-
-export function parseManagedInstanceShutdownMessage(
-  value: unknown,
-): ManagedInstanceShutdownMessage | null {
-  if (!isRecord(value)) return null;
-  return value["type"] === MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE &&
-    typeof value["controlToken"] === "string"
-    ? { type: MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE, controlToken: value["controlToken"] }
-    : null;
-}
-import { parseBackendImplementation, type BackendImplementation } from "./backendImplementation";

package/src/lib/mask.ts

@@ -1,4 +0,0 @@
-export function maskApiKey(apiKey: string): string {
-  if (apiKey.length <= 8) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
-  return apiKey.slice(0, 4) + "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" + apiKey.slice(-4);
-}

package/src/lib/objectUtils.ts

@@ -1,22 +0,0 @@
-/**
- * Generic object utilities shared across API format modules.
- * Only truly format-agnostic helpers belong here; Anthropic/OpenAI-specific
- * checks stay in their respective API format modules.
- */
-
-/**
- * Returns true if `val` is a plain object (not null, not an array).
- */
-export function isPlainRecord(val: unknown): val is Record<string, unknown> {
-  return typeof val === "object" && val !== null && !Array.isArray(val);
-}
-
-/**
- * Safe property access via Object.getOwnPropertyDescriptor.
- * Returns `undefined` when obj is not an object or the property does not exist.
- */
-export function safeGetOwnProperty(obj: unknown, key: string): unknown {
-  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return undefined;
-  const desc = Object.getOwnPropertyDescriptor(obj, key);
-  return desc?.value;
-}

package/src/lib/piAgentContract.ts

@@ -1,102 +0,0 @@
-import { z } from "zod";
-import { LogIdSchema } from "../contracts";
-
-export const PiAgentHistoryMessageSchema = z.object({
-  role: z.enum(["user", "assistant"]),
-  content: z.string().trim().min(1).max(4_000),
-});
-
-export const PiAgentEvidenceSourceSchema = z.enum([
-  "log",
-  "knowledge",
-  "alert",
-  "run",
-  "group",
-  "provider",
-]);
-
-export const PiAgentCountEntrySchema = z.object({
-  value: z.string(),
-  count: z.number().int().nonnegative(),
-});
-
-export const PiAgentSummarySchema = z.object({
-  matchedLogs: z.number().int().nonnegative(),
-  knowledgeMatched: z.number().int().nonnegative(),
-  failures: z.number().int().nonnegative(),
-  pending: z.number().int().nonnegative(),
-  sessions: z.number().int().nonnegative(),
-  models: z.array(PiAgentCountEntrySchema),
-  providers: z.array(PiAgentCountEntrySchema),
-  latency: z.object({
-    count: z.number().int().nonnegative(),
-    minMs: z.number().nullable(),
-    maxMs: z.number().nullable(),
-    averageMs: z.number().nullable(),
-  }),
-  tokens: z.object({
-    input: z.number().int().nonnegative(),
-    output: z.number().int().nonnegative(),
-    total: z.number().int().nonnegative(),
-  }),
-  sourceCounts: z.record(PiAgentEvidenceSourceSchema, z.number().int().nonnegative()),
-});
-
-export const PiAgentQueryStatsSchema = z.object({
-  scannedLogs: z.number().int().nonnegative(),
-  hydratedLogs: z.number().int().nonnegative(),
-  matchedLogs: z.number().int().nonnegative(),
-  scannedKnowledge: z.number().int().nonnegative(),
-  matchedKnowledge: z.number().int().nonnegative(),
-  returnedEvidence: z.number().int().nonnegative(),
-  truncated: z.boolean(),
-  durationMs: z.number().nonnegative(),
-});
-
-export const PiAgentEvidenceSchema = z.object({
-  source: PiAgentEvidenceSourceSchema,
-  id: z.string(),
-  logId: LogIdSchema.optional(),
-  knowledgeId: z.string().optional(),
-  logIds: z.array(LogIdSchema).optional(),
-  timestamp: z.string().optional(),
-  sessionId: z.string().optional(),
-  model: z.string().optional(),
-  providerName: z.string().optional(),
-  path: z.string().optional(),
-  status: z.union([z.number(), z.string()]).nullable().optional(),
-  elapsedMs: z.number().optional(),
-  inputTokens: z.number().int().nonnegative().optional(),
-  outputTokens: z.number().int().nonnegative().optional(),
-  score: z.number(),
-  matchedFields: z.array(z.string()),
-  excerpt: z.string(),
-  entityType: z.string().optional(),
-  title: z.string().optional(),
-  knowledgeType: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-});
-
-export const PiAgentRequestSchema = z.object({
-  question: z.string().trim().min(1).max(4_000),
-  sessionId: z.string().trim().min(1).optional(),
-  providerId: z.string().trim().min(1).optional(),
-  model: z.string().trim().min(1).optional(),
-  logLimit: z.number().int().min(1).max(80).optional(),
-  history: z.array(PiAgentHistoryMessageSchema).max(12).optional(),
-});
-
-export const PiAgentResponseSchema = z.object({
-  answer: z.string(),
-  providerId: z.string(),
-  providerName: z.string(),
-  model: z.string(),
-  protocol: z.enum(["openaiResponses", "openaiChat", "anthropic"]),
-  logCount: z.number().int().nonnegative(),
-  evidence: z.array(PiAgentEvidenceSchema).optional(),
-  summary: PiAgentSummarySchema.optional(),
-  queryStats: PiAgentQueryStatsSchema.optional(),
-});
-
-export type PiAgentRequest = z.infer<typeof PiAgentRequestSchema>;
-export type PiAgentResponse = z.infer<typeof PiAgentResponseSchema>;

package/src/lib/providerContract.ts

@@ -1,125 +0,0 @@
-import { z } from "zod";
-import {
-  MAX_PROVIDER_MODEL_METADATA,
-  MAX_PROVIDER_MODEL_NAME_CHARS,
-  MAX_PROVIDER_MODELS,
-} from "./resourceLimits";
-
-/**
- * Validates that a string is a well-formed http(s) URL. Rejects non-HTTP
- * schemes (file:, ftp:, etc.) that could be used for SSRF. Local/private
- * addresses are allowed because this tool legitimately proxies to local LLM
- * servers (Ollama, LM Studio, etc.).
- */
-function httpUrl(): z.ZodString {
-  return z.string().refine((val) => {
-    // Treat empty strings as "unset" so legacy/in-flight providers that
-    // store empty placeholders instead of null can still round-trip.
-    if (val.length === 0) return true;
-    try {
-      const parsed = new URL(val);
-      return parsed.protocol === "http:" || parsed.protocol === "https:";
-    } catch {
-      return false;
-    }
-  }, "Must be a valid http(s) URL");
-}
-
-export const ProviderModelNameSchema = z.string().max(MAX_PROVIDER_MODEL_NAME_CHARS);
-export const ProviderModelsSchema = z.array(ProviderModelNameSchema).max(MAX_PROVIDER_MODELS);
-
-export const ProviderModelMetadataSchema = z.object({
-  model: ProviderModelNameSchema.min(1),
-  contextWindow: z.number().int().positive().optional(),
-  outputLimit: z.number().int().positive().optional(),
-  source: z.enum(["manual", "registry"]).optional(),
-  sourceUrl: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-
-export const ProviderModelMetadataListSchema = z
-  .array(ProviderModelMetadataSchema)
-  .max(MAX_PROVIDER_MODEL_METADATA);
-
-/**
- * Persisted provider shape shared by the server store and browser API clients.
- *
- * Keep this module free of filesystem and process-level imports so client code
- * can validate API responses without pulling the provider store into the bundle.
- */
-export const ProviderConfigSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  apiKey: z.string(),
-  model: ProviderModelNameSchema.optional(),
-  models: ProviderModelsSchema.optional().default([]),
-  format: z.enum(["anthropic", "openai"]).optional(),
-  baseUrl: httpUrl().optional(),
-  anthropicBaseUrl: httpUrl().optional(),
-  openaiBaseUrl: httpUrl().optional(),
-  openaiResponsesBaseUrl: httpUrl().optional(),
-  authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
-  apiDocsUrl: z.string().optional(),
-  modelMetadataUrl: z.string().optional(),
-  modelMetadata: ProviderModelMetadataListSchema.optional(),
-  source: z.enum(["company", "personal"]).optional(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-});
-
-export const REDACTED_PROVIDER_API_KEY = "configured";
-
-/**
- * Secret-safe provider shape used at every API and tool output boundary.
- *
- * Keeping the marker in the existing `apiKey` field preserves compatibility
- * with older browser clients while making plaintext provider credentials
- * impossible to represent in a validated response.
- */
-export const RedactedProviderDtoSchema = ProviderConfigSchema.extend({
-  apiKey: z.literal(REDACTED_PROVIDER_API_KEY),
-});
-
-export type ProviderModelMetadata = z.infer<typeof ProviderModelMetadataSchema>;
-export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
-export type RedactedProviderDto = z.infer<typeof RedactedProviderDtoSchema>;
-
-export type ProviderModelLimitViolation = {
-  resource: "provider-models" | "provider-model-metadata";
-  limit: number;
-};
-
-function arrayFieldLength(value: unknown, key: string): number | null {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-  const descriptor = Object.getOwnPropertyDescriptor(value, key);
-  if (descriptor === undefined) return null;
-  const field: unknown = descriptor.value;
-  return Array.isArray(field) ? field.length : null;
-}
-
-export function getProviderModelLimitViolation(value: unknown): ProviderModelLimitViolation | null {
-  const modelCount = arrayFieldLength(value, "models");
-  if (modelCount !== null && modelCount > MAX_PROVIDER_MODELS) {
-    return { resource: "provider-models", limit: MAX_PROVIDER_MODELS };
-  }
-
-  const metadataCount = arrayFieldLength(value, "modelMetadata");
-  if (metadataCount !== null && metadataCount > MAX_PROVIDER_MODEL_METADATA) {
-    return { resource: "provider-model-metadata", limit: MAX_PROVIDER_MODEL_METADATA };
-  }
-
-  return null;
-}
-
-export function toRedactedProviderDto(provider: ProviderConfig): RedactedProviderDto {
-  return {
-    ...provider,
-    apiKey: REDACTED_PROVIDER_API_KEY,
-  };
-}
-
-export function toRedactedProviderDtos(
-  providers: readonly ProviderConfig[],
-): RedactedProviderDto[] {
-  return providers.map(toRedactedProviderDto);
-}

package/src/lib/providerImportContract.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-
-export const ScannedProviderDtoSchema = z.object({
-  selectionId: z.string().uuid(),
-  name: z.string(),
-  apiKeyHint: z.string(),
-  format: z.enum(["anthropic", "openai"]),
-  anthropicBaseUrl: z.string(),
-  openaiBaseUrl: z.string(),
-  openaiResponsesBaseUrl: z.string().optional().default(""),
-  models: z.array(z.string()),
-  sourceTool: z.enum(["claude-code", "opencode", "mimo-code"]),
-  alreadyExists: z.boolean(),
-});
-
-export const ProviderScanResponseSchema = z.object({
-  scanId: z.string().uuid(),
-  providers: z.array(ScannedProviderDtoSchema),
-  warnings: z.array(z.string()).optional(),
-});
-
-export const ProviderScanImportRequestSchema = z.object({
-  scanId: z.string().uuid(),
-  selectionIds: z.array(z.string().uuid()).min(1).max(100),
-});
-
-export type ScannedProviderDto = z.infer<typeof ScannedProviderDtoSchema>;