@tonyclaw/agent-inspector 2.1.16 → 2.1.17

package/src/lib/upstreamUrl.ts

@@ -1,9 +1,24 @@
 export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
 export const PATH_V1_RESPONSES = "/v1/responses";
+export const PATH_V1_MESSAGES = "/v1/messages";
+
+export type UpstreamUrlDiagnostic = {
+  severity: "info" | "warning";
+  message: string;
+};
+
+export type UpstreamUrlPreviewOptions = {
+  providerName?: string;
+};
+
+export type UpstreamUrlPreview = {
+  finalUrl: string;
+  diagnostics: UpstreamUrlDiagnostic[];
+};
 
 export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
   const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
-  const endpointPath = normalizedPath.split("?")[0] ?? normalizedPath;
+  const endpointPath = endpointPathFor(normalizedPath);
   const queryIndex = normalizedPath.indexOf("?");
   const search = queryIndex >= 0 ? normalizedPath.slice(queryIndex) : "";
 
@@ -24,6 +39,62 @@ export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string):
   return base + normalizedPath;
 }
 
+export function previewUpstreamUrl(
+  upstreamBase: string,
+  normalizedPath: string,
+  options: UpstreamUrlPreviewOptions = {},
+): UpstreamUrlPreview {
+  const base = upstreamBase.trim().replace(/\/+$/, "");
+  const endpointPath = endpointPathFor(normalizedPath);
+  const finalUrl = buildUpstreamUrl(base, normalizedPath);
+  const diagnostics: UpstreamUrlDiagnostic[] = [];
+  const exactEndpoint = endpointPath !== "" && base.endsWith(endpointPath);
+
+  if (exactEndpoint) {
+    diagnostics.push({
+      severity: "info",
+      message: "This already includes the exact endpoint; no duplicate suffix will be appended.",
+    });
+  } else if (isZhipuVersionedOpenAIBase(base) && isVersionedChatCompletionsPath(normalizedPath)) {
+    diagnostics.push({
+      severity: "info",
+      message: "Zhipu bases already include the API version; only /chat/completions is appended.",
+    });
+  } else if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+    diagnostics.push({
+      severity: "info",
+      message: "Base URL already ends with /v1; the suffix will not repeat /v1.",
+    });
+  }
+
+  if (isResponsesPath(endpointPath) && baseEndsWithChatEndpoint(base)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "This looks like a Chat Completions endpoint, so Responses would append after it.",
+    });
+  }
+
+  if (isChatCompletionsPath(endpointPath) && baseEndsWithResponsesEndpoint(base)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "This looks like a Responses endpoint, so Chat Completions would append after it.",
+    });
+  }
+
+  if (isResponsesPath(endpointPath) && isLikelyDeepSeekBase(base, options.providerName)) {
+    diagnostics.push({
+      severity: "warning",
+      message: "DeepSeek's official API does not currently expose OpenAI Responses.",
+    });
+  }
+
+  return { finalUrl, diagnostics };
+}
+
+function endpointPathFor(normalizedPath: string): string {
+  return normalizedPath.split("?")[0] ?? normalizedPath;
+}
+
 function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
   return (
     normalizedPath === PATH_V1_CHAT_COMPLETIONS ||
@@ -32,6 +103,39 @@ function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
   );
 }
 
+function isChatCompletionsPath(endpointPath: string): boolean {
+  return (
+    endpointPath === PATH_V1_CHAT_COMPLETIONS ||
+    endpointPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}/`)
+  );
+}
+
+function isResponsesPath(endpointPath: string): boolean {
+  return endpointPath === PATH_V1_RESPONSES || endpointPath.startsWith(`${PATH_V1_RESPONSES}/`);
+}
+
+function baseEndsWithChatEndpoint(base: string): boolean {
+  const normalized = base.toLowerCase();
+  return normalized.endsWith("/chat/completions");
+}
+
+function baseEndsWithResponsesEndpoint(base: string): boolean {
+  const normalized = base.toLowerCase();
+  return normalized.endsWith("/responses");
+}
+
+function isLikelyDeepSeekBase(base: string, providerName: string | undefined): boolean {
+  const provider = providerName?.toLowerCase();
+  if (provider !== undefined && provider.includes("deepseek")) return true;
+
+  try {
+    const parsed = new URL(base);
+    return parsed.hostname.toLowerCase().includes("deepseek");
+  } catch {
+    return base.toLowerCase().includes("deepseek");
+  }
+}
+
 function isZhipuVersionedOpenAIBase(base: string): boolean {
   try {
     const parsed = new URL(base);

package/src/mcp/toolHandlers.ts

@@ -907,7 +907,7 @@ function providerDiagnosticHints(result: unknown): string[] {
   }
   if (text.includes("nonstream") || text.includes("non-stream")) {
     hints.push(
-      "The failure mentions non-streaming. Compare the OpenAI/Anthropic non-streaming path and payload with the streaming request.",
+      "The failure mentions non-streaming. Compare the Anthropic, OpenAI Chat, and OpenAI Responses non-streaming path and payload with the streaming request.",
     );
   }
   return [...new Set(hints)];

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

@@ -6,6 +6,7 @@ import { buildProviderTestSessionId } from "../../proxy/sessionSupervisor";
 import { buildProviderTestRequestBody } from "../../lib/providerTestPrompt";
 import {
   ProviderTestResultsSchema,
+  type ProviderModelTestResults,
   type ProviderTestResult as TestResult,
   type ProviderTestState,
 } from "../../lib/providerTestContract";
@@ -55,11 +56,9 @@ async function logModelResults(
   providerName: string,
   providerSessionId: string,
   anthropicUrl: string | undefined,
-  openaiUrl: string | undefined,
-  modelResults: {
-    anthropic: { nonStreaming: ProviderTestState; streaming: ProviderTestState };
-    openai: { nonStreaming: ProviderTestState; streaming: ProviderTestState };
-  },
+  openaiChatUrl: string | undefined,
+  openaiResponsesUrl: string | undefined,
+  modelResults: ProviderModelTestResults,
   captureFullDetails: boolean,
 ): Promise<void> {
   const usageModel = getModelUsageName(displayName, providerName);
@@ -132,9 +131,9 @@ async function logModelResults(
     }
   }
 
-  if (openaiUrl !== undefined) {
-    const nsResult = modelResults.openai.nonStreaming;
-    const sResult = modelResults.openai.streaming;
+  if (openaiChatUrl !== undefined) {
+    const nsResult = modelResults.openaiChat.nonStreaming;
+    const sResult = modelResults.openaiChat.streaming;
     if (hasSuccessField(nsResult) && hasSuccessField(sResult)) {
       const nonStreamingResult = nsResult;
       const streamingResult = sResult;
@@ -199,6 +198,76 @@ async function logModelResults(
       });
     }
   }
+
+  if (openaiResponsesUrl !== undefined) {
+    const nsResult = modelResults.openaiResponses.nonStreaming;
+    const sResult = modelResults.openaiResponses.streaming;
+    if (hasSuccessField(nsResult) && hasSuccessField(sResult)) {
+      const nonStreamingResult = nsResult;
+      const streamingResult = sResult;
+
+      const requestBody = JSON.stringify(
+        buildProviderTestRequestBody(usageModel, "non-streaming", "responses"),
+      );
+
+      await addTestLogEntry({
+        timestamp: new Date().toISOString(),
+        method: "POST",
+        path: "/v1/responses",
+        model: nonStreamingResult.model ?? displayName,
+        sessionId: providerSessionId,
+        rawRequestBody: requestBody,
+        responseStatus: getResultResponseStatus(nonStreamingResult),
+        responseText: getResultResponseText(nonStreamingResult),
+        inputTokens: nonStreamingResult.inputTokens ?? null,
+        outputTokens: nonStreamingResult.outputTokens ?? null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: nonStreamingResult.cacheReadInputTokens ?? null,
+        elapsedMs: nonStreamingResult.latencyMs ?? 0,
+        firstChunkMs: null,
+        totalStreamMs: null,
+        tokensPerSecond: null,
+        streaming: false,
+        userAgent: "provider-test",
+        origin: null,
+        apiFormat: "openai",
+        isTest: true,
+        providerName,
+        headers: captureFullDetails ? getResultHeaders(nonStreamingResult) : undefined,
+      });
+
+      const streamingRequestBody = JSON.stringify(
+        buildProviderTestRequestBody(usageModel, "streaming", "responses"),
+      );
+
+      await addTestLogEntry({
+        timestamp: new Date().toISOString(),
+        method: "POST",
+        path: "/v1/responses",
+        model: streamingResult.model ?? displayName,
+        sessionId: providerSessionId,
+        rawRequestBody: streamingRequestBody,
+        responseStatus: getResultResponseStatus(streamingResult),
+        responseText: getResultResponseText(streamingResult),
+        inputTokens: streamingResult.inputTokens ?? null,
+        outputTokens: streamingResult.outputTokens ?? null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: streamingResult.cacheReadInputTokens ?? null,
+        elapsedMs: getResultTotalStreamMs(streamingResult) ?? 0,
+        firstChunkMs: getResultFirstChunkMs(streamingResult),
+        totalStreamMs: getResultTotalStreamMs(streamingResult),
+        tokensPerSecond: getResultTokensPerSecond(streamingResult),
+        streaming: true,
+        streamingChunks: captureFullDetails ? streamingResult.streamingChunks : undefined,
+        userAgent: "provider-test",
+        origin: null,
+        apiFormat: "openai",
+        isTest: true,
+        providerName,
+        headers: captureFullDetails ? getResultHeaders(streamingResult) : undefined,
+      });
+    }
+  }
 }
 
 export const Route = createFileRoute("/api/providers/$providerId/test/log")({
@@ -232,10 +301,15 @@ export const Route = createFileRoute("/api/providers/$providerId/test/log")({
           provider.anthropicBaseUrl !== undefined && provider.anthropicBaseUrl.length > 0
             ? provider.anthropicBaseUrl
             : undefined;
-        const openaiUrl =
+        const openaiChatUrl =
           provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.length > 0
             ? provider.openaiBaseUrl
             : undefined;
+        const openaiResponsesUrl =
+          provider.openaiResponsesBaseUrl !== undefined &&
+          provider.openaiResponsesBaseUrl.length > 0
+            ? provider.openaiResponsesBaseUrl
+            : undefined;
 
         const entries: Promise<void>[] = [];
         if (results.models !== undefined) {
@@ -246,7 +320,8 @@ export const Route = createFileRoute("/api/providers/$providerId/test/log")({
                 provider.name,
                 providerSessionId,
                 anthropicUrl,
-                openaiUrl,
+                openaiChatUrl,
+                openaiResponsesUrl,
                 modelResult,
                 captureFullDetails,
               ),