Remove legacy discovery fallback for 0.3.3 (#5)

Author: kev1n

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.3
+
+### Changed
+
+- Discovery now accepts only the customer-safe contract: AnyAPI branding,
+  nested USD pricing, `relevance`, and `ranking`.
+
+### Removed
+
+- Removed the temporary 0.3.2 compatibility reader for credit-based catalog
+  responses and the former search field aliases.
+
 ## 0.3.2
 
 ### Changed

__tests__/discovery.test.ts

@@ -3,30 +3,13 @@ import { AnyApiClient } from '../src/api.js';
 import { formatCatalogPrice } from '../src/format.js';
 import type { FetchLike } from '../src/types.js';
 
-const legacyList = {
-  apis: [{
-    slug: 'reddit.search',
-    category: 'social',
-    name: 'Reddit Search',
-    description: 'Search Reddit',
-    fromCredits: 400,
-    baseCredits: 5,
-    perItemCredits: 10,
-    perItemUnit: 'result',
-    providers: ['hidden-upstream'],
-    quotes: [
-      { fromCredits: 400, baseCredits: 5, perItemCredits: 10, uptimePct: 99.5, latencyP50Ms: 240, requests: 80 },
-      { fromCredits: 500, baseCredits: 10, perItemCredits: 12 },
-    ],
-  }],
-};
-
-const replacementList = {
+const catalogResponse = {
   apis: [{
     id: 'reddit.search',
     slug: 'reddit.search',
     category: 'social',
     name: 'Reddit Search',
+    description: 'Search Reddit',
     provider: 'AnyAPI',
     pricing: {
       from: { model: 'linear', unit: 'result', baseUsd: 0.00005, perUnitUsd: 0.0001, maxUsd: 0.004 },
@@ -36,52 +19,50 @@ const replacementList = {
       pricing: { model: 'linear', unit: 'result', baseUsd: 0.00005, perUnitUsd: 0.0001, maxUsd: 0.004 },
       health: { window: '30d', uptimePct: 99.5, latencyP50Ms: 240, requests: 80 },
     }],
+    tryEligible: true,
   }],
 };
 
-describe('discovery compatibility reader', () => {
-  it('normalizes the legacy browse response into nested USD pricing', async () => {
-    const client = clientFor(legacyList);
+describe('customer-safe discovery reader', () => {
+  it('reads browse responses with discriminated nested USD pricing', async () => {
+    let requested = '';
+    const client = clientFor(catalogResponse, (url) => { requested = url; });
     const response = await client.catalog({ category: 'social' });
 
-    expect(response.apis[0]).toMatchObject({
-      slug: 'reddit.search',
-      category: 'social',
-      name: 'Reddit Search',
-      description: 'Search Reddit',
-      provider: 'AnyAPI',
-      pricing: replacementList.apis[0]!.pricing,
-    });
-    expect(response.apis[0]!.lanes).toHaveLength(2);
-    expect(response.apis[0]!.lanes?.[0]).toEqual(replacementList.apis[0]!.lanes?.[0]);
+    const url = new URL(requested);
+    expect(url.pathname).toBe('/catalog');
+    expect(Object.fromEntries(url.searchParams)).toEqual({ category: 'social' });
+    expect(response).toEqual(catalogResponse);
     expect(formatCatalogPrice(response.apis[0]!)).toBe(
       'from USD 0.00005 + USD 0.0001/result (max USD 0.0040/request)',
     );
-    expect(JSON.stringify(response)).not.toMatch(/credit|hidden-upstream/i);
+    expectCustomerSafe(response);
   });
 
-  it('passes the replacement browse response through the same customer-safe model', async () => {
-    const client = clientFor(replacementList);
-    const response = await client.catalog();
-
-    expect(response).toEqual(replacementList);
-  });
-
-  it('uses dedicated search and adapts the legacy per-1k result', async () => {
+  it('uses dedicated ranked search and accepts only relevance and ranking', async () => {
     let requested = '';
     const client = clientFor({
       results: [{
         slug: 'amazon.product',
+        platformId: 'amazon',
         name: 'Amazon Product',
+        description: 'Get product details',
         category: 'shopping',
-        priceUsdPer1k: 5,
-        score: 0.8,
+        provider: 'AnyAPI',
+        pricing: {
+          from: { model: 'flat', unit: 'request', maxUsd: 0.005 },
+          failoverMaxUsd: 0.006,
+        },
+        relevance: 0.92,
+        highlightFields: [{ path: 'items[].price', type: 'number' }],
       }],
       total: 1,
-      mode: 'usecase',
+      ranking: 'semantic',
     }, (url) => { requested = url; });
 
-    const response = await client.search({ query: 'wireless headphones', category: 'shopping', platform: 'amazon', limit: 10 });
+    const response = await client.search({
+      query: 'wireless headphones', category: 'shopping', platform: 'amazon', limit: 10,
+    });
 
     const url = new URL(requested);
     expect(url.pathname).toBe('/catalog/search');
@@ -91,109 +72,91 @@ describe('discovery compatibility reader', () => {
       platform: 'amazon',
       limit: '10',
     });
-    expect(response).toEqual({
-      results: [{
-        slug: 'amazon.product',
-        name: 'Amazon Product',
-        category: 'shopping',
-        provider: 'AnyAPI',
-        pricing: {
-          from: { model: 'flat', unit: 'request', maxUsd: 0.005 },
-          failoverMaxUsd: 0.005,
-        },
-        relevance: 0.8,
-      }],
+    expect(response).toMatchObject({
       total: 1,
-      ranking: 'usecase',
-    });
-  });
-
-  it('reads replacement ranked search results without legacy fields', async () => {
-    const client = clientFor({
+      ranking: 'semantic',
       results: [{
         slug: 'amazon.product',
-        name: 'Amazon Product',
         provider: 'AnyAPI',
-        pricing: {
-          from: { model: 'flat', unit: 'request', maxUsd: 0.005 },
-          failoverMaxUsd: 0.006,
-        },
+        pricing: { from: { model: 'flat', unit: 'request', maxUsd: 0.005 } },
         relevance: 0.92,
-        highlightFields: [{ path: 'items[].price', type: 'number' }],
       }],
-      total: 1,
-      ranking: 'semantic',
-    });
-
-    const response = await client.search({ query: 'product prices' });
-
-    expect(response.ranking).toBe('semantic');
-    expect(response.results[0]).toMatchObject({
-      slug: 'amazon.product',
-      provider: 'AnyAPI',
-      pricing: { from: { model: 'flat', unit: 'request', maxUsd: 0.005 } },
-      relevance: 0.92,
-      highlightFields: [{ path: 'items[].price', type: 'number' }],
     });
+    expectCustomerSafe(response);
   });
 
-  it('normalizes a legacy describe response before customer sanitization', async () => {
+  it('reads authenticated detail responses with schemas', async () => {
     let authorization = '';
-    const client = clientFor({
-      id: 'youtube.comments',
-      slug: 'youtube.comments',
-      name: 'YouTube Comments',
-      description: 'Read comments',
-      priceCredits: 2000,
-      fromCredits: 1500,
-      baseCredits: 0,
-      perItemCredits: 0,
-      inputSchema: { type: 'object' },
+    const body = {
+      ...catalogResponse.apis[0],
+      inputSchema: { type: 'object', properties: { query: { type: 'string' } } },
       outputSchema: { type: 'array' },
-      provider: 'hidden-upstream',
-    }, undefined, (init) => {
+      heavy: true,
+    };
+    const client = clientFor(body, undefined, (init) => {
       authorization = new Headers(init?.headers).get('Authorization') ?? '';
     }, true);
 
-    const response = await client.describe('youtube.comments');
+    const response = await client.describe('reddit.search');
 
     expect(authorization).toBe('Bearer aa_live_test');
-    expect(response).toEqual({
-      id: 'youtube.comments',
-      slug: 'youtube.comments',
-      name: 'YouTube Comments',
-      description: 'Read comments',
-      inputSchema: { type: 'object' },
-      outputSchema: { type: 'array' },
-      provider: 'AnyAPI',
-      pricing: {
-        from: { model: 'flat', unit: 'request', maxUsd: 0.015 },
-        failoverMaxUsd: 0.02,
-      },
-    });
-    expect(JSON.stringify(response)).not.toMatch(/credit|hidden-upstream/i);
+    expect(response).toEqual(body);
+    expectCustomerSafe(response);
   });
 
-  it('reads a replacement describe response with schemas and discriminated pricing', async () => {
+  it('recursively strips forbidden accounting and provider metadata', async () => {
     const body = {
-      id: 'youtube.comments',
-      slug: 'youtube.comments',
-      name: 'YouTube Comments',
-      provider: 'AnyAPI',
-      pricing: {
-        from: { model: 'flat', unit: 'request', maxUsd: 0.015 },
-        failoverMaxUsd: 0.02,
+      ...catalogResponse.apis[0],
+      provider: 'hidden-upstream',
+      inputSchema: {
+        type: 'object',
+        internalCredits: 500,
+        provider: 'hidden-upstream',
+        providers: ['hidden-upstream'],
+        properties: { query: { type: 'string' } },
       },
-      inputSchema: { type: 'object' },
-      outputSchema: { type: 'array' },
-      heavy: true,
     };
     const client = clientFor(body, undefined, undefined, true);
 
-    expect(await client.describe('youtube.comments')).toEqual(body);
+    const response = await client.describe('reddit.search');
+
+    expect(JSON.stringify(response)).not.toContain('hidden-upstream');
+    expectCustomerSafe(response);
+  });
+
+  it('rejects discovery entries without nested pricing', async () => {
+    const client = clientFor({
+      apis: [{
+        slug: 'reddit.search',
+        category: 'social',
+        name: 'Reddit Search',
+        description: 'Search Reddit',
+        provider: 'AnyAPI',
+      }],
+    });
+
+    await expect(client.catalog()).rejects.toThrow('Invalid AnyAPI API discovery response.');
   });
 });
 
+function expectCustomerSafe(value: unknown): void {
+  if (Array.isArray(value)) {
+    value.forEach(expectCustomerSafe);
+    return;
+  }
+  if (typeof value !== 'object' || value === null) {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    expect(key.toLowerCase()).not.toContain('credit');
+    expect(key.toLowerCase()).not.toBe('providers');
+    if (key.toLowerCase() === 'provider') {
+      expect(child).toBe('AnyAPI');
+    }
+    expectCustomerSafe(child);
+  }
+}
+
 function clientFor(
   body: unknown,
   onUrl?: (url: string) => void,

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "anyapi-cli",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Official CLI for AnyAPI, a unified marketplace for scraping and data APIs.",
   "type": "module",
   "bin": {

package.json

@@ -34,6 +34,8 @@ Search and list are public. Describe is authenticated because it returns the ful
 - `anyapi search <query>` uses the dedicated ranked discovery search.
 - `anyapi list --category <cat>` narrows by category.
 - `anyapi describe <sku>` prints input schema, output schema, and USD pricing.
+- Discovery pricing is always nested under `pricing`; ranked search reports
+  `relevance` per result and `ranking` for the response.
 
 ## Tips
 

skills/anyapi-discover/SKILL.md

@@ -2,6 +2,7 @@ import { CATALOG_URL, REST_BASE_URL, SIGNUP_URL } from './constants.js';
 import { readCatalogResponse, readDiscoveryApi, readSearchResponse } from './discovery.js';
 import { ApiError } from './errors.js';
 import type {
+  CatalogApi,
   CatalogResponse,
   ClientRegistrationResponse,
   FetchLike,
@@ -117,11 +118,11 @@ export class AnyApiClient {
     return readSearchResponse(body);
   }
 
-  async describe(sku: string): Promise<unknown> {
+  async describe(sku: string): Promise<CatalogApi> {
     const body = await this.requestJson<unknown>(`${this.restBaseUrl}/apis/${encodeURIComponent(sku)}`, {
       headers: this.authHeaders(),
     }, { sanitize: false });
-    return readDiscoveryApi(body) ?? sanitizeCustomerJson(body);
+    return readDiscoveryApi(body);
   }
 
   // run always fetches the FULL result. Response shaping (fields/max_items/summary/