@tonyclaw/agent-inspector 3.0.25 → 3.0.27

package/src/proxy/providerSecretStore.ts

@@ -0,0 +1,181 @@
+import { createCipheriv, createDecipheriv, randomBytes, timingSafeEqual } from "node:crypto";
+import { Buffer } from "node:buffer";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { logger } from "./logger";
+
+const SECRET_REFERENCE_PREFIX = "secret:provider:";
+const SECRET_FILE_VERSION = 1;
+const KEY_BYTES = 32;
+const IV_BYTES = 12;
+const AUTH_TAG_BYTES = 16;
+
+const SecretFileSchema = z.object({
+  version: z.literal(SECRET_FILE_VERSION),
+  secrets: z.record(z.string(), z.string()),
+});
+
+type SecretFile = z.infer<typeof SecretFileSchema>;
+
+export type ProviderSecretStore = {
+  delete: (providerId: string) => void;
+  isReference: (value: string) => boolean;
+  read: (reference: string) => string | null;
+  write: (providerId: string, secret: string) => string | null;
+};
+
+function emptySecretFile(): SecretFile {
+  return { version: SECRET_FILE_VERSION, secrets: {} };
+}
+
+function readSecretFile(path: string): SecretFile {
+  if (!existsSync(path)) return emptySecretFile();
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    const result = SecretFileSchema.safeParse(parsed);
+    if (result.success) return result.data;
+    logger.warn(`[provider-secrets] Ignoring invalid secret file ${path}`);
+  } catch (error) {
+    logger.warn(`[provider-secrets] Could not read ${path}: ${String(error)}`);
+  }
+  return emptySecretFile();
+}
+
+function writePrivateFile(path: string, content: string): boolean {
+  const temporaryPath = `${path}.${String(process.pid)}.tmp`;
+  try {
+    writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 0o600 });
+    chmodSync(temporaryPath, 0o600);
+    renameSync(temporaryPath, path);
+    chmodSync(path, 0o600);
+    return true;
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    logger.error(`[provider-secrets] Could not write ${path}: ${String(error)}`);
+    return false;
+  }
+}
+
+function readKey(path: string): Buffer | null {
+  try {
+    if (!existsSync(path)) return null;
+    const key = Buffer.from(readFileSync(path, "utf8").trim(), "base64");
+    if (key.byteLength === KEY_BYTES) return key;
+    logger.error(`[provider-secrets] Invalid encryption key at ${path}`);
+    return null;
+  } catch (error) {
+    logger.error(`[provider-secrets] Could not read encryption key: ${String(error)}`);
+    return null;
+  }
+}
+
+function readOrCreateKey(keyPath: string, secretsPath: string): Buffer | null {
+  const existingKey = readKey(keyPath);
+  if (existingKey !== null) return existingKey;
+  if (existsSync(keyPath)) return null;
+
+  if (existsSync(secretsPath)) {
+    logger.error(
+      `[provider-secrets] Refusing to replace missing key while encrypted secrets exist at ${secretsPath}`,
+    );
+    return null;
+  }
+
+  const key = randomBytes(KEY_BYTES);
+  if (!writePrivateFile(keyPath, key.toString("base64"))) return null;
+  return key;
+}
+
+function encrypt(secret: string, key: Buffer): string | null {
+  try {
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([cipher.update(secret, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, ciphertext]).toString("base64");
+  } catch (error) {
+    logger.error(`[provider-secrets] Encryption failed: ${String(error)}`);
+    return null;
+  }
+}
+
+function decrypt(payload: string, key: Buffer): string | null {
+  try {
+    const packed = Buffer.from(payload, "base64");
+    if (packed.byteLength <= IV_BYTES + AUTH_TAG_BYTES) return null;
+    const iv = packed.subarray(0, IV_BYTES);
+    const tag = packed.subarray(IV_BYTES, IV_BYTES + AUTH_TAG_BYTES);
+    const ciphertext = packed.subarray(IV_BYTES + AUTH_TAG_BYTES);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+function providerIdFromReference(reference: string): string | null {
+  if (!reference.startsWith(SECRET_REFERENCE_PREFIX)) return null;
+  const providerId = reference.slice(SECRET_REFERENCE_PREFIX.length);
+  return providerId === "" ? null : providerId;
+}
+
+export function createProviderSecretStore(directory: string): ProviderSecretStore {
+  mkdirSync(directory, { recursive: true });
+  const keyPath = join(directory, "provider-secrets.key");
+  const secretsPath = join(directory, "provider-secrets.json");
+
+  function writeSecrets(data: SecretFile): boolean {
+    return writePrivateFile(secretsPath, JSON.stringify(data, null, 2));
+  }
+
+  return {
+    isReference: (value) => providerIdFromReference(value) !== null,
+    write: (providerId, secret) => {
+      const key = readOrCreateKey(keyPath, secretsPath);
+      if (key === null) return null;
+      const encrypted = encrypt(secret, key);
+      if (encrypted === null) return null;
+      const data = readSecretFile(secretsPath);
+      const next = {
+        ...data,
+        secrets: { ...data.secrets, [providerId]: encrypted },
+      };
+      if (!writeSecrets(next)) return null;
+      return `${SECRET_REFERENCE_PREFIX}${providerId}`;
+    },
+    read: (reference) => {
+      const providerId = providerIdFromReference(reference);
+      if (providerId === null) return null;
+      const key = readKey(keyPath);
+      if (key === null) return null;
+      const encrypted = readSecretFile(secretsPath).secrets[providerId];
+      if (encrypted === undefined) return null;
+      return decrypt(encrypted, key);
+    },
+    delete: (providerId) => {
+      const data = readSecretFile(secretsPath);
+      if (data.secrets[providerId] === undefined) return;
+      const nextSecrets = { ...data.secrets };
+      delete nextSecrets[providerId];
+      void writeSecrets({ ...data, secrets: nextSecrets });
+    },
+  };
+}
+
+export function secretValuesEqual(left: string, right: string): boolean {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  return (
+    leftBuffer.byteLength === rightBuffer.byteLength && timingSafeEqual(leftBuffer, rightBuffer)
+  );
+}

package/src/proxy/providers.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import Conf from "conf";
 import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { maskApiKey } from "../lib/mask";
 import { logger } from "./logger";
 import { getDataDir, hasExplicitDataDir } from "./dataDir";
@@ -13,6 +13,11 @@ import {
   type ProviderModelMetadata,
 } from "../lib/providerContract";
 import { withBuiltinProviderModelMetadata } from "../lib/providerModelMetadata";
+import {
+  createProviderSecretStore,
+  secretValuesEqual,
+  type ProviderSecretStore,
+} from "./providerSecretStore";
 
 export { ProviderConfigSchema };
 export type { ProviderConfig };
@@ -198,8 +203,7 @@ function migrateFromLegacyConfLocation(targetStore: Conf<ProvidersStore>): void
   }
 }
 
-// Using conf for storage - works in any Node.js environment without Electron
-// Note: conf stores data in plain JSON. For production, consider additional encryption.
+// Provider metadata uses Conf; API keys are stored separately by ProviderSecretStore.
 const configPath = process.env["AGENT_INSPECTOR_CONFIG_PATH"];
 
 // The data directory is shared with the runtime config (`config.ts`).
@@ -222,6 +226,69 @@ export const store = new Conf<ProvidersStore>({
   ...(configPath !== undefined ? { path: configPath } : {}),
 });
 
+const providerSecretStore: ProviderSecretStore = createProviderSecretStore(dirname(store.path));
+
+function providerWithResolvedSecret(provider: ProviderConfig): ProviderConfig | null {
+  if (!providerSecretStore.isReference(provider.apiKey)) return provider;
+  const apiKey = providerSecretStore.read(provider.apiKey);
+  if (apiKey !== null) return { ...provider, apiKey };
+  logger.error(`[providers] Secret is missing or unreadable for provider "${provider.name}"`);
+  return null;
+}
+
+function persistProviders(
+  providers: readonly ProviderConfig[],
+  removedProviderIds: ReadonlySet<string> = new Set(),
+): void {
+  const existingReferences = new Map<string, string>();
+  const unresolvedRecords = new Map<string, ProviderConfig>();
+  for (const candidate of store.get("providers", [])) {
+    const parsed = ProviderConfigSchema.safeParse(candidate);
+    if (parsed.success && providerSecretStore.isReference(parsed.data.apiKey)) {
+      existingReferences.set(parsed.data.id, parsed.data.apiKey);
+      if (providerSecretStore.read(parsed.data.apiKey) === null) {
+        unresolvedRecords.set(parsed.data.id, parsed.data);
+      }
+    }
+  }
+
+  const persisted = providers.map((provider) => {
+    const existingReference = existingReferences.get(provider.id);
+    if (existingReference !== undefined) {
+      const existingSecret = providerSecretStore.read(existingReference);
+      if (existingSecret !== null && secretValuesEqual(existingSecret, provider.apiKey)) {
+        return { ...provider, apiKey: existingReference };
+      }
+    }
+
+    const reference = providerSecretStore.write(provider.id, provider.apiKey);
+    if (reference !== null) return { ...provider, apiKey: reference };
+    logger.error(
+      `[providers] SecretStore unavailable; provider "${provider.name}" remains in the legacy storage format`,
+    );
+    return provider;
+  });
+  const persistedIds = new Set(persisted.map((provider) => provider.id));
+  for (const [id, provider] of unresolvedRecords) {
+    if (!persistedIds.has(id) && !removedProviderIds.has(id)) persisted.push(provider);
+  }
+  store.set("providers", persisted);
+}
+
+function migratePlaintextProviderSecrets(): void {
+  const raw = store.get("providers", []);
+  let changed = false;
+  const migrated = raw.map((candidate) => {
+    const parsed = ProviderConfigSchema.safeParse(candidate);
+    if (!parsed.success || providerSecretStore.isReference(parsed.data.apiKey)) return candidate;
+    const reference = providerSecretStore.write(parsed.data.id, parsed.data.apiKey);
+    if (reference === null) return candidate;
+    changed = true;
+    return { ...parsed.data, apiKey: reference };
+  });
+  if (changed) store.set("providers", migrated);
+}
+
 // Older builds stored providers in `<dataDir>/config.json`. Migrate that
 // shape before checking the older Conf-managed default location.
 migrateFromDataDirConfig(store, dataDir);
@@ -378,6 +445,10 @@ if (providersJson !== undefined) {
   }
 }
 
+// One-time, backwards-compatible migration. Existing plaintext keys are moved
+// out of providers.json; records retain only opaque references.
+migratePlaintextProviderSecrets();
+
 export function getProviders(): ProviderConfig[] {
   const raw = store.get("providers", []);
   // Validate the on-disk store entry-by-entry so a single corrupted record
@@ -388,7 +459,8 @@ export function getProviders(): ProviderConfig[] {
   for (const candidate of raw) {
     const entry = ProviderConfigSchema.safeParse(candidate);
     if (entry.success) {
-      valid.push(entry.data);
+      const resolved = providerWithResolvedSecret(entry.data);
+      if (resolved !== null) valid.push(resolved);
       continue;
     }
     let candidateName = "<unknown>";
@@ -411,7 +483,7 @@ export function getProvider(id: string): ProviderConfig | undefined {
 export function redactProvider(provider: ProviderConfig): ProviderConfig {
   return {
     ...provider,
-    apiKey: maskApiKey(provider.apiKey),
+    apiKey: "configured",
   };
 }
 
@@ -454,7 +526,7 @@ export function addProvider(
   // merge the new models into it instead of creating a duplicate.
   const existing = providers.find(
     (p) =>
-      p.apiKey === normalizedKey &&
+      secretValuesEqual(p.apiKey, normalizedKey) &&
       (p.anthropicBaseUrl ?? "") === (resolvedAnthropicUrl ?? "") &&
       (p.openaiBaseUrl ?? "") === (resolvedOpenaiUrl ?? "") &&
       (p.openaiResponsesBaseUrl ?? "") === (resolvedOpenaiResponsesUrl ?? ""),
@@ -474,7 +546,7 @@ export function addProvider(
     if (existingIndex >= 0) {
       providers[existingIndex] = enriched;
     }
-    store.set("providers", providers);
+    persistProviders(providers);
     return enriched;
   }
 
@@ -506,7 +578,7 @@ export function addProvider(
     now,
   );
   providers.push(newProvider);
-  store.set("providers", providers);
+  persistProviders(providers);
   return newProvider;
 }
 
@@ -554,7 +626,7 @@ export function updateProvider(
   );
   const index = providers.findIndex((p) => p.id === id);
   providers[index] = updated;
-  store.set("providers", providers);
+  persistProviders(providers);
   return updated;
 }
 
@@ -563,7 +635,8 @@ export function deleteProvider(id: string): boolean {
   const filtered = providers.filter((p) => p.id !== id);
   if (filtered.length === providers.length) return false;
 
-  store.set("providers", filtered);
+  persistProviders(filtered, new Set([id]));
+  providerSecretStore.delete(id);
   return true;
 }
 
@@ -665,7 +738,7 @@ export function importProviders(json: string): { imported: number; errors: strin
 
     // Single write: append all new providers at once
     if (newProviders.length > 0) {
-      store.set("providers", [...existingProviders, ...newProviders]);
+      persistProviders([...existingProviders, ...newProviders]);
     }
   } catch (err) {
     return {

package/src/proxy/schemas.ts

@@ -5,7 +5,6 @@ export type {
   CapturedLog,
   ApiFormat,
   JsonValue,
-  RequestFormat,
   StreamingChunk,
   TokenUsage,
 } from "../contracts";
@@ -18,15 +17,9 @@ export type {
 export {
   AnthropicRequestSchema,
   AnthropicResponseSchema,
-  InspectorRequestSchema,
-  InspectorResponseSchema,
   SseEventSchema,
 } from "../contracts/anthropic";
-export type {
-  AnthropicResponse,
-  InspectorResponse,
-  ResponseContentBlockType,
-} from "../contracts/anthropic";
+export type { AnthropicResponse, ResponseContentBlockType } from "../contracts/anthropic";
 
 export {
   OpenAIRequestSchema,

package/src/proxy/sqliteLogIndex.ts

@@ -8,12 +8,6 @@ type SqliteState =
   | { status: "ready"; db: unknown; path: string }
   | { status: "unavailable"; path: string; reason: string };
 
-type SqliteStatus = {
-  available: boolean;
-  path: string;
-  reason: string | null;
-};
-
 const SQLITE_INDEX_FILE = "inspector.sqlite";
 const SQLITE_PACKAGE_NAME = "better-sqlite3";
 const BUN_SQLITE_MODULE_NAME = "bun:sqlite";
@@ -493,16 +487,6 @@ function entryFromRow(row: unknown): LogIndexEntry | null {
   };
 }
 
-export async function getSqliteLogIndexStatus(): Promise<SqliteStatus> {
-  const state = await getSqliteState();
-  switch (state.status) {
-    case "ready":
-      return { available: true, path: state.path, reason: null };
-    case "unavailable":
-      return { available: false, path: state.path, reason: state.reason };
-  }
-}
-
 export async function getSqliteLogIndexMaxId(): Promise<number | null> {
   const state = await getSqliteState();
   if (state.status !== "ready") return null;

package/src/proxy/store.ts

@@ -35,6 +35,7 @@ import {
 import { writeChunks } from "./chunkStorage";
 import { closeSqliteLogIndex } from "./sqliteLogIndex";
 import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
+import { textByteLength } from "../lib/unknown";
 import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
 import { CapturedLogSchema } from "./schemas";
@@ -263,11 +264,6 @@ function removeFromCache(id: number): void {
   removeLogsFromCursorPageIndexes(new Set([id]));
 }
 
-function textByteLength(value: string | null): number | null {
-  if (value === null) return null;
-  return Buffer.byteLength(value, "utf8");
-}
-
 export function compactLogForList(log: CapturedLog): CapturedLog {
   return {
     ...log,

package/src/proxy/toolSchemaWarnings.ts

@@ -1,4 +1,5 @@
 import type { ApiFormat } from "./schemas";
+import { isRecord, readProperty } from "../lib/unknown";
 
 type JsonObject = Record<string, unknown>;
 
@@ -33,15 +34,6 @@ function parseJson(raw: string | null): ParsedJson {
   }
 }
 
-function isRecord(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readProperty(value: unknown, key: string): unknown {
-  if (!isRecord(value)) return undefined;
-  return Object.getOwnPropertyDescriptor(value, key)?.value;
-}
-
 function hasOwnProperty(value: JsonObject, key: string): boolean {
   return Object.getOwnPropertyDescriptor(value, key) !== undefined;
 }

package/src/routes/api/logs.$id.replay.ts

@@ -22,6 +22,7 @@ import {
   setUpstreamHost,
 } from "../../proxy/upstream";
 import { computeTokensPerSecond } from "../../proxy/streamTiming";
+import { safeFetch } from "../../lib/safeFetch";
 
 type ReplayRequest = {
   modifiedBody: string;
@@ -127,11 +128,22 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
         // Send request
         let upstreamRes: Response;
         try {
-          upstreamRes = await fetch(upstreamUrl, {
-            method: "POST",
-            headers,
-            body: modifiedBody,
-          });
+          const fetchResult = await safeFetch(
+            upstreamUrl,
+            {
+              method: "POST",
+              headers,
+              body: modifiedBody,
+            },
+            { allowLoopback: process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1" },
+          );
+          if (!fetchResult.ok) {
+            return Response.json({
+              success: false,
+              error: fetchResult.reason,
+            } satisfies ReplayResponse);
+          }
+          upstreamRes = fetchResult.response;
         } catch (err) {
           return Response.json({
             success: false,

package/src/routes/api/providers.$providerId.model-metadata.ts

@@ -7,6 +7,7 @@ import {
   BUILTIN_MODEL_METADATA_SOURCE_URL,
   ProviderModelRegistrySchema,
 } from "../../lib/providerModelMetadata";
+import { safeFetch } from "../../lib/safeFetch";
 
 const RefreshModelMetadataInputSchema = z.object({
   url: z.string().optional(),
@@ -79,7 +80,16 @@ export const Route = createFileRoute("/api/providers/$providerId/model-metadata"
 
         let response: Response;
         try {
-          response = await fetch(sourceUrl, { headers: { Accept: "application/json" } });
+          const fetchResult = await safeFetch(sourceUrl, {
+            headers: { Accept: "application/json" },
+          });
+          if (!fetchResult.ok) {
+            return Response.json(
+              { error: `Model metadata URL blocked: ${fetchResult.reason}` },
+              { status: 400 },
+            );
+          }
+          response = fetchResult.response;
         } catch (err) {
           return Response.json(
             { error: `Failed to fetch model metadata: ${String(err)}` },

package/src/routes/api/providers.$providerId.ts

@@ -7,6 +7,9 @@ import {
   redactProvider,
 } from "../../proxy/providers";
 import { ProviderModelMetadataSchema } from "../../lib/providerContract";
+import { evaluateUpstreamUrl } from "../../lib/ssrfGuard";
+
+const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 
 const ProviderUpdateSchema = z.object({
   name: z.string().min(1, "Name is required").optional(),
@@ -28,26 +31,36 @@ const ProviderUpdateSchema = z.object({
 export const Route = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
-      GET: ({ params, request }: { params: { providerId: string }; request: Request }) => {
-        const url = new URL(request.url);
-        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
+      GET: ({ params }: { params: { providerId: string } }) => {
         const providers = getProviders();
         const provider = providers.find((p) => p.id === params.providerId);
         if (!provider) {
           return Response.json({ error: "Provider not found" }, { status: 404 });
         }
-        return Response.json(includeSecrets ? provider : redactProvider(provider));
+        return Response.json(redactProvider(provider));
       },
       PUT: async ({ params, request }: { params: { providerId: string }; request: Request }) => {
         const parsed = ProviderUpdateSchema.safeParse(await request.json());
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }
+        for (const candidate of [
+          parsed.data.baseUrl,
+          parsed.data.anthropicBaseUrl,
+          parsed.data.openaiBaseUrl,
+          parsed.data.openaiResponsesBaseUrl,
+        ]) {
+          if (candidate === undefined || candidate === "") continue;
+          const decision = evaluateUpstreamUrl(candidate, { allowLoopback: ALLOW_LOOPBACK });
+          if (!decision.allow) {
+            return Response.json({ error: decision.reason }, { status: 400 });
+          }
+        }
         const updated = updateProvider(params.providerId, parsed.data);
         if (!updated) {
           return Response.json({ error: "Provider not found" }, { status: 404 });
         }
-        return Response.json(updated);
+        return Response.json(redactProvider(updated));
       },
       DELETE: ({ params }: { params: { providerId: string } }) => {
         const deleted = deleteProvider(params.providerId);

package/src/routes/api/providers.ts

@@ -1,7 +1,10 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { z } from "zod";
-import { getProviders, addProvider, redactProviders } from "../../proxy/providers";
+import { getProviders, addProvider, redactProvider, redactProviders } from "../../proxy/providers";
 import { ProviderModelMetadataSchema } from "../../lib/providerContract";
+import { evaluateUpstreamUrl } from "../../lib/ssrfGuard";
+
+const ALLOW_LOOPBACK = process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1";
 
 const ProviderInputSchema = z.object({
   name: z.string().min(1, "Name is required"),
@@ -22,17 +25,25 @@ const ProviderInputSchema = z.object({
 export const Route = createFileRoute("/api/providers")({
   server: {
     handlers: {
-      GET: ({ request }: { request: Request }) => {
-        const url = new URL(request.url);
-        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
-        const providers = getProviders();
-        return Response.json(includeSecrets ? providers : redactProviders(providers));
+      GET: () => {
+        return Response.json(redactProviders(getProviders()));
       },
       POST: async ({ request }: { request: Request }) => {
         const parsed = ProviderInputSchema.safeParse(await request.json());
         if (!parsed.success) {
           return Response.json({ error: parsed.error.message }, { status: 400 });
         }
+        for (const candidate of [
+          parsed.data.anthropicBaseUrl,
+          parsed.data.openaiBaseUrl,
+          parsed.data.openaiResponsesBaseUrl,
+        ]) {
+          if (candidate === undefined || candidate === "") continue;
+          const decision = evaluateUpstreamUrl(candidate, { allowLoopback: ALLOW_LOOPBACK });
+          if (!decision.allow) {
+            return Response.json({ error: decision.reason }, { status: 400 });
+          }
+        }
         const newProvider = addProvider(
           parsed.data.name,
           parsed.data.apiKey,
@@ -48,7 +59,7 @@ export const Route = createFileRoute("/api/providers")({
           parsed.data.modelMetadata,
           parsed.data.openaiResponsesBaseUrl,
         );
-        return Response.json(newProvider, { status: 201 });
+        return Response.json(redactProvider(newProvider), { status: 201 });
       },
     },
   },