@antseed/cli 0.1.152 → 0.1.154

package/dist/proxy/buyer-proxy.js

@@ -8,7 +8,7 @@ import { canonicalModelKey } from '@antseed/node/model-identity';
 import { createStreamingAdapter, detectRequestServiceApiProtocol, transformRequest, transformResponse, } from './service-api-adapter.js';
 import { DEBUG, log, extractRequestedService, summarizeRequestShape, summarizeErrorResponse, requestWantsStreaming, parsePeerPinnedService, rewritePeerPinnedServiceInBody, substituteRoutedModelAlias, overrideRoutedModelInBody, ROUTED_MODEL_ALIAS, SYSTEM_PROXY_SOURCE_HEADER, SYSTEM_ROUTED_MODEL_HEADER, normalizePeerId, } from './request-utils.js';
 import { buildNetworkModels, effectiveModelReputationScore, normalizedModelReputationScore, parseModelTypeFilter, } from './network-models.js';
-import { findUnannouncedRequestParameters, findAdvertisedServiceOffer, getExplicitProviderOverride, getExplicitPeerIdOverride, resolvePeerRoutePlan, selectCandidatePeersForRouting, } from './routing.js';
+import { findMissingRequiredParameters, findUnannouncedRequestParameters, findAdvertisedServiceOffer, getExplicitProviderOverride, getExplicitPeerIdOverride, parseRequiredParametersHeader, REQUIRED_PARAMETERS_HEADER, resolvePeerRoutePlan, selectCandidatePeersForRouting, } from './routing.js';
 import { computeResponseTelemetry, attachAntseedTelemetryHeaders, attachStreamingAntseedHeaders, } from './telemetry.js';
 import { DEFAULT_BUYER_PEER_REFRESH_INTERVAL_MS } from '../config/defaults.js';
 import { extractConversationIdentity, extractFirstUserSnippet, isCompletionRequestPath, isTitleGenerationRequest, parseRequestBodyObject, } from './conversation-identity.js';
@@ -21,6 +21,11 @@ import { loadConfig } from '../config/loader.js';
 // Re-export for backward compatibility (used by tests and other consumers)
 export { selectCandidatePeersForRouting } from './routing.js';
 export { parsePeerPinnedService, rewritePeerPinnedServiceInBody, substituteRoutedModelAlias, ROUTED_MODEL_ALIAS } from './request-utils.js';
+const WATCHER_ABSENCE_ERRORS = {
+    'payments-disabled': 'Deposit watcher unavailable — payments are disabled on this buyer.',
+    'no-deposit-relay': 'Deposit watcher unavailable — this chain has no deposit relay.',
+    'external-daemon': 'Deposit watcher unavailable — another daemon owns the proxy port and runs the watcher.',
+};
 const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
 const MODEL_RATE_LIMIT_MAX_ATTEMPTS_PER_PEER = 3;
 const MODEL_RATE_LIMIT_RETRY_DELAYS_MS = [250, 750];
@@ -227,7 +232,7 @@ function adaptBuyerFaultErrorResponse(response, requestProtocol) {
         body: Buffer.from(JSON.stringify(body)),
     };
 }
-function sanitizePeerBuyerFaultMarker(response) {
+export function sanitizePeerBuyerFaultMarker(response) {
     if (response.statusCode < 400)
         return response;
     let parsed;
@@ -237,18 +242,28 @@ function sanitizePeerBuyerFaultMarker(response) {
     catch {
         return response;
     }
+    // Scrub the whole tree, not just the top level: a seller nesting the marker
+    // deeper (e.g. error.details.code) must not be able to have its failure
+    // classified as buyer-fault downstream. Iterate to avoid recursion limits
+    // without leaving deeply nested markers trusted by downstream clients.
     let changed = false;
-    const scrub = (record) => {
+    const pending = [parsed];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (value === null || typeof value !== 'object')
+            continue;
+        if (Array.isArray(value)) {
+            pending.push(...value);
+            continue;
+        }
+        const record = value;
         for (const key of ['code', 'type', 'errorCode']) {
             if (record[key] === ANTSEED_BUYER_FAULT_ERROR_CODE) {
                 record[key] = 'upstream_error';
                 changed = true;
             }
         }
-    };
-    scrub(parsed);
-    if (parsed.error && typeof parsed.error === 'object' && !Array.isArray(parsed.error)) {
-        scrub(parsed.error);
+        pending.push(...Object.values(record));
     }
     return changed
         ? { ...response, body: Buffer.from(JSON.stringify(parsed)) }
@@ -615,6 +630,8 @@ export class BuyerProxy {
      * plane instead of running a second signer against the same wallet.
      */
     _depositWatcher = null;
+    /** Why no watcher is attached, so UIs can show the actual cause. */
+    _depositWatcherAbsence = null;
     /**
      * requestId -> the conversation that issued it, so the node's per-request
      * spend events can be attributed to a chat. Only the proxy knows this
@@ -708,9 +725,13 @@ export class BuyerProxy {
             this._requestConversations.delete(oldest);
         }
     }
-    /** Attach the hot-wallet deposit watcher (owned by `buyer start`). */
-    setDepositWatcher(watcher) {
+    /**
+     * Attach the hot-wallet deposit watcher (owned by `buyer start`), or record
+     * why none runs so the status endpoint can report the cause.
+     */
+    setDepositWatcher(watcher, absenceReason = null) {
         this._depositWatcher = watcher;
+        this._depositWatcherAbsence = watcher ? null : absenceReason;
     }
     /** Latest relayer receipt for a sweep authNonce, if one has arrived. */
     getSweepReceipt(authNonce) {
@@ -1706,6 +1727,13 @@ export class BuyerProxy {
             res.end(JSON.stringify({
                 ok: true,
                 watcher: this._depositWatcher !== null,
+                // Why no watcher runs (null while one is attached) — lets UIs say
+                // "payments are disabled" vs "this chain has no deposit relay".
+                reason: this._depositWatcher ? null : this._depositWatcherAbsence,
+                // Live payments health: configured/active flags + chain-RPC
+                // reachability from the node's background monitor. Optional call —
+                // tolerate an older @antseed/node without it.
+                payments: this._node.getPaymentsStatus?.() ?? null,
                 status: this._depositWatcher?.status() ?? null,
             }));
             return;
@@ -1739,11 +1767,10 @@ export class BuyerProxy {
             }
             const watcher = this._depositWatcher;
             if (!watcher) {
+                const reason = this._depositWatcherAbsence;
+                const error = (reason && WATCHER_ABSENCE_ERRORS[reason]) ?? 'Deposit watcher unavailable.';
                 res.writeHead(503, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({
-                    ok: false,
-                    error: 'Deposit watcher unavailable — payments are disabled or this chain has no deposit relay.',
-                }));
+                res.end(JSON.stringify({ ok: false, reason, error }));
                 return;
             }
             if (mode === 'active')
@@ -1890,6 +1917,19 @@ export class BuyerProxy {
             headers,
             body: new Uint8Array(body),
         };
+        const requiredParameters = parseRequiredParametersHeader(serializedReq.headers[REQUIRED_PARAMETERS_HEADER]);
+        if (requiredParameters === null) {
+            res.writeHead(400, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                error: {
+                    type: 'invalid_request_error',
+                    code: 'invalid_required_parameters',
+                    message: `${REQUIRED_PARAMETERS_HEADER} must contain at most 16 comma-separated parameter names.`,
+                    param: REQUIRED_PARAMETERS_HEADER,
+                },
+            }));
+            return;
+        }
         // Snapshot the session overrides before any await so a concurrent
         // _reloadSessionOverrides() cannot change routing mid-request.
         const effectivePinnedPeer = this._pinnedPeer;
@@ -2088,6 +2128,14 @@ export class BuyerProxy {
                 const offer = findAdvertisedServiceOffer(peer, plan.provider, plan.serviceId);
                 if (!offer)
                     return null;
+                const missingRequired = plan.selection?.requiresTransform
+                    ? requiredParameters
+                    : findMissingRequiredParameters(peer, plan.provider, plan.serviceId, requiredParameters);
+                if (missingRequired.length > 0) {
+                    log(`Capability filter: peer ${peer.peerId.slice(0, 12)}... service="${plan.serviceId}" `
+                        + `missing required parameter(s): ${missingRequired.join(', ')}`);
+                    return null;
+                }
                 const requestForPolicy = withRoutedModel(serializedReq, plan.serviceId);
                 if (!peerAllowedByPolicy(policyRouter, requestForPolicy, peer))
                     return null;
@@ -2137,14 +2185,22 @@ export class BuyerProxy {
                 }
             }
             if (candidates.length === 0) {
-                res.writeHead(502, { 'content-type': 'application/json' });
+                const capabilityRequired = requiredParameters.length > 0;
+                res.writeHead(capabilityRequired ? 422 : 502, { 'content-type': 'application/json' });
                 res.end(JSON.stringify({
-                    error: {
-                        type: 'model_not_found',
-                        code: 'model_not_found',
-                        message: `No policy-allowed peer currently serves model "${requestedService}".`,
-                        param: 'model',
-                    },
+                    error: capabilityRequired
+                        ? {
+                            type: 'required_capability_unavailable',
+                            code: 'required_capability_unavailable',
+                            message: `No policy-allowed seller for model "${requestedService}" advertises required parameter(s): ${requiredParameters.join(', ')}.`,
+                            param: REQUIRED_PARAMETERS_HEADER,
+                        }
+                        : {
+                            type: 'model_not_found',
+                            code: 'model_not_found',
+                            message: `No policy-allowed peer currently serves model "${requestedService}".`,
+                            param: 'model',
+                        },
                 }));
                 return;
             }
@@ -2304,6 +2360,21 @@ export class BuyerProxy {
         const selectedPlan = routingPlans.get(selectedPeer.peerId)
             ?? resolvePeerRoutePlan(selectedPeer, requestProtocol, requestedService, explicitProvider, 'lenient');
         const pinnedServiceId = selectedPlan?.serviceId ?? requestedService;
+        const missingRequired = selectedPlan && !selectedPlan.selection?.requiresTransform
+            ? findMissingRequiredParameters(selectedPeer, selectedPlan.provider, pinnedServiceId, requiredParameters)
+            : requiredParameters;
+        if (missingRequired.length > 0) {
+            res.writeHead(422, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                error: {
+                    type: 'required_capability_unavailable',
+                    code: 'required_capability_unavailable',
+                    message: `Pinned seller does not advertise required parameter(s) for model "${pinnedServiceId ?? requestedService ?? 'unknown'}": ${missingRequired.join(', ')}.`,
+                    param: REQUIRED_PARAMETERS_HEADER,
+                },
+            }));
+            return;
+        }
         const pinnedRequest = pinnedServiceId ? withRoutedModel(serializedReq, pinnedServiceId) : serializedReq;
         if (!peerAllowedByPolicy(policyRouter, pinnedRequest, selectedPeer)) {
             log(`Pinned peer ${selectedPeer.peerId.slice(0, 12)}... filtered out by buyer routing policy`);
@@ -2418,7 +2489,7 @@ export class BuyerProxy {
                     + `did not announce for this service: ${unannounced.join(', ')} — the upstream may ignore or reject them`);
             }
         }
-        const { 'x-antseed-pin-peer': _pinPeer, 'x-antseed-prefer-peer': _preferPeer, 'x-vpr-session-id': _vprSession, 
+        const { 'x-antseed-pin-peer': _pinPeer, 'x-antseed-prefer-peer': _preferPeer, [REQUIRED_PARAMETERS_HEADER]: _requiredParameters, 'x-vpr-session-id': _vprSession, 
         // Legacy desktop builds (pre AntStation → VPR rename) still send this.
         'x-antstation-session-id': _antstationSession, ...headersForPeer } = serializedReq.headers;
         let requestForPeer = {