newmark-agent 0.5.14 → 0.6.0

package/dist/providers/provider-headers.d.ts

@@ -1,9 +1,13 @@
 import { ProviderResponseMetadata } from './provider-adapter';
-export declare function headerGet(headers: Headers | Record<string, string>, name: string): string | null;
-export declare function normalizeProviderHeaders(headers: Headers | Record<string, string>): ProviderResponseMetadata;
+/** Native, cross-realm and custom transport Headers share the same get shape. */
+export type ProviderHeaderInput = Headers | Record<string, string> | {
+    get(name: string): string | null;
+};
+export declare function headerGet(headers: ProviderHeaderInput, name: string): string | null;
+export declare function normalizeProviderHeaders(headers: ProviderHeaderInput): ProviderResponseMetadata;
 /**
  * Filter a header record for request-side diagnostics: only explicitly allowed
  * non-sensitive fields are retained. Never returns cookies or credentials.
  */
-export declare function filterRequestHeadersForDiagnostics(headers: Record<string, string>): Record<string, string>;
+export declare function filterRequestHeadersForDiagnostics(headers: ProviderHeaderInput): Record<string, string>;
 //# sourceMappingURL=provider-headers.d.ts.map

package/dist/providers/provider-headers.js

@@ -11,17 +11,29 @@ exports.filterRequestHeadersForDiagnostics = filterRequestHeadersForDiagnostics;
 const ALLOWED_HEADERS = new Set([
     'x-request-id',
     'request-id',
-    'x-request-id',
     'x-correlation-id',
     'x-amzn-requestid',
     'x-amzn-trace-id',
     'x-ratelimit-limit',
     'x-ratelimit-remaining',
     'x-ratelimit-reset',
+    'x-ratelimit-limit-requests',
+    'x-ratelimit-remaining-requests',
+    'x-ratelimit-reset-requests',
+    'x-ratelimit-limit-tokens',
+    'x-ratelimit-remaining-tokens',
+    'x-ratelimit-reset-tokens',
+    'anthropic-ratelimit-requests-limit',
+    'anthropic-ratelimit-requests-remaining',
+    'anthropic-ratelimit-requests-reset',
+    'anthropic-ratelimit-tokens-limit',
+    'anthropic-ratelimit-tokens-remaining',
+    'anthropic-ratelimit-tokens-reset',
     'ratelimit-limit',
     'ratelimit-remaining',
     'ratelimit-reset',
     'retry-after',
+    'retry-after-ms',
     'x-cache',
     'x-cache-status',
     'cf-cache-status',
@@ -38,15 +50,80 @@ const FORBIDDEN_HEADERS = new Set([
     'x-github-token',
 ]);
 function headerGet(headers, name) {
-    if (typeof Headers !== 'undefined' && headers instanceof Headers) {
-        return headers.get(name);
+    if (!headers || typeof headers !== 'object')
+        return null;
+    const getter = headers.get;
+    if (typeof getter === 'function') {
+        try {
+            const value = getter.call(headers, name.toLowerCase());
+            if (typeof value === 'string')
+                return value;
+        }
+        catch { /* A malformed custom container can still expose a plain record. */ }
     }
     const record = headers;
     const key = Object.keys(record).find(k => k.toLowerCase() === name.toLowerCase());
-    return key === undefined ? null : record[key];
+    return key === undefined || typeof record[key] !== 'string' ? null : record[key];
+}
+function nonNegativeNumber(value) {
+    if (value === null || !/^\d+(?:\.\d+)?$/.test(value.trim()))
+        return undefined;
+    const numeric = Number(value.trim());
+    return Number.isFinite(numeric) && numeric <= Number.MAX_SAFE_INTEGER ? numeric : undefined;
+}
+function validIso(milliseconds) {
+    if (!Number.isFinite(milliseconds))
+        return '';
+    const date = new Date(milliseconds);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : '';
+}
+function durationMilliseconds(value) {
+    const text = value.trim().toLowerCase();
+    if (!/^(?:\d+(?:\.\d+)?(?:ms|s|m|h|d))+$/.test(text))
+        return undefined;
+    const units = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+    let duration = 0;
+    for (const match of text.matchAll(/(\d+(?:\.\d+)?)(ms|s|m|h|d)/g))
+        duration += Number(match[1]) * units[match[2]];
+    return Number.isFinite(duration) && duration <= Number.MAX_SAFE_INTEGER ? duration : undefined;
+}
+function resetTime(value, kind, now) {
+    if (value === null || !value.trim())
+        return '';
+    const numeric = nonNegativeNumber(value);
+    if (kind === 'duration') {
+        const duration = durationMilliseconds(value) ?? (numeric === undefined ? undefined : numeric * 1000);
+        return duration === undefined ? '' : validIso(now + duration);
+    }
+    if (kind === 'epoch' && numeric !== undefined) {
+        // GitHub's x-ratelimit-reset is epoch seconds. Some compatible gateways
+        // publish epoch milliseconds; neither format is a relative duration.
+        return validIso(numeric >= 1e12 ? numeric : numeric * 1000);
+    }
+    if (numeric !== undefined || !/[A-Za-z]|\d[Tt]\d/.test(value))
+        return '';
+    return validIso(Date.parse(value));
+}
+function retryAfterSeconds(headers, now) {
+    // Matches the official OpenAI SDK's precedence for the nonstandard precise
+    // millisecond extension. A real zero remains authoritative.
+    const milliseconds = nonNegativeNumber(headerGet(headers, 'retry-after-ms'));
+    if (milliseconds !== undefined)
+        return milliseconds / 1000;
+    const raw = headerGet(headers, 'retry-after');
+    const seconds = nonNegativeNumber(raw);
+    if (seconds !== undefined)
+        return seconds;
+    // Reject malformed numeric values instead of letting Date.parse interpret
+    // values such as "-1" as an unrelated calendar date.
+    if (!raw || !/[A-Za-z]/.test(raw))
+        return undefined;
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? Math.max(0, Math.ceil((parsed - now) / 1000)) : undefined;
 }
 function normalizeProviderHeaders(headers) {
     const result = {};
+    const now = Date.now();
     const requestId = headerGet(headers, 'x-request-id') ||
         headerGet(headers, 'request-id') ||
         headerGet(headers, 'x-correlation-id') ||
@@ -56,46 +133,30 @@ function normalizeProviderHeaders(headers) {
     const traceId = headerGet(headers, 'x-amzn-trace-id');
     if (traceId)
         result.traceId = traceId;
-    const limitRaw = headerGet(headers, 'x-ratelimit-limit');
-    const remainingRaw = headerGet(headers, 'x-ratelimit-remaining');
-    const resetRaw = headerGet(headers, 'x-ratelimit-reset');
-    if (limitRaw && remainingRaw) {
-        const limit = Number(limitRaw);
-        const remaining = Number(remainingRaw);
-        let resetAt = '';
-        if (resetRaw) {
-            const numeric = Number(resetRaw);
-            if (Number.isFinite(numeric) && numeric > 1e10)
-                resetAt = new Date(numeric).toISOString();
-            else if (Number.isFinite(numeric))
-                resetAt = new Date(Date.now() + numeric * 1000).toISOString();
-            else {
-                const parsed = Date.parse(resetRaw);
-                if (Number.isFinite(parsed))
-                    resetAt = new Date(parsed).toISOString();
-            }
-        }
-        if (Number.isFinite(limit) && Number.isFinite(remaining)) {
-            result.rateLimit = { limit, remaining, resetAt };
-        }
-    }
-    const retryAfter = headerGet(headers, 'retry-after');
-    if (retryAfter) {
-        if (/^\d+(?:\.\d+)?$/.test(retryAfter)) {
-            result.retryAfterSeconds = Number(retryAfter);
-        }
-        else {
-            const parsed = Date.parse(retryAfter);
-            if (Number.isFinite(parsed)) {
-                result.retryAfterSeconds = Math.max(0, Math.ceil((parsed - Date.now()) / 1000));
-            }
-        }
+    const families = [
+        ['x-ratelimit-limit-requests', 'x-ratelimit-remaining-requests', 'x-ratelimit-reset-requests', 'duration'],
+        ['anthropic-ratelimit-requests-limit', 'anthropic-ratelimit-requests-remaining', 'anthropic-ratelimit-requests-reset', 'date'],
+        ['x-ratelimit-limit', 'x-ratelimit-remaining', 'x-ratelimit-reset', 'epoch'],
+        ['ratelimit-limit', 'ratelimit-remaining', 'ratelimit-reset', 'duration'],
+    ];
+    for (const [limitName, remainingName, resetName, resetKind] of families) {
+        const limit = nonNegativeNumber(headerGet(headers, limitName));
+        const remaining = nonNegativeNumber(headerGet(headers, remainingName));
+        if (limit === undefined || remaining === undefined || !Number.isInteger(limit) || !Number.isInteger(remaining))
+            continue;
+        result.rateLimit = { limit, remaining, resetAt: resetTime(headerGet(headers, resetName), resetKind, now) };
+        break;
     }
+    const retryAfter = retryAfterSeconds(headers, now);
+    if (retryAfter !== undefined)
+        result.retryAfterSeconds = retryAfter;
     const cacheStateRaw = headerGet(headers, 'x-cache-status') ||
         headerGet(headers, 'cf-cache-status') ||
         headerGet(headers, 'x-cache') ||
         headerGet(headers, 'x-vercel-cache');
     if (cacheStateRaw) {
+        // This is HTTP/CDN cache metadata only. It cannot establish model token
+        // cache usage or a prompt-cache hit ratio; those require response usage.
         const lower = cacheStateRaw.toLowerCase();
         result.cacheState = lower.includes('hit') ? 'hit' : lower.includes('miss') ? 'miss' : 'unknown';
     }
@@ -107,13 +168,22 @@ function normalizeProviderHeaders(headers) {
  */
 function filterRequestHeadersForDiagnostics(headers) {
     const out = {};
+    if (headers && typeof headers.get === 'function') {
+        for (const key of ALLOWED_HEADERS) {
+            const value = headerGet(headers, key);
+            if (value !== null)
+                out[key] = value;
+        }
+        return out;
+    }
     for (const [key, value] of Object.entries(headers || {})) {
         const lower = key.toLowerCase();
         if (FORBIDDEN_HEADERS.has(lower))
             continue;
         if (!ALLOWED_HEADERS.has(lower))
             continue;
-        out[key] = value;
+        if (typeof value === 'string')
+            out[key] = value;
     }
     return out;
 }

package/dist/providers/provider-request-compat.d.ts

@@ -0,0 +1,6 @@
+/** Request construction shared by Chat, Responses and native protocol paths. */
+export type RequestProtocol = 'openai' | 'anthropic' | 'github_models';
+export declare function providerRequestHeaders(protocol: RequestProtocol, apiKey: string, stream?: boolean): Record<string, string>;
+/** Preserve custom gateway prefixes and queries; replace only known endpoints. */
+export declare function providerEndpoint(baseUrl: string, endpoint: string): string;
+//# sourceMappingURL=provider-request-compat.d.ts.map

package/dist/providers/provider-request-compat.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerRequestHeaders = providerRequestHeaders;
+exports.providerEndpoint = providerEndpoint;
+function providerRequestHeaders(protocol, apiKey, stream = false) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: stream ? 'text/event-stream' : protocol === 'github_models' ? 'application/vnd.github+json' : 'application/json',
+    };
+    // Local compatible servers may intentionally have no authentication. Never
+    // substitute a fake key or send an empty Bearer credential to such servers.
+    if (apiKey)
+        headers[protocol === 'anthropic' ? 'x-api-key' : 'Authorization'] = protocol === 'anthropic' ? apiKey : `Bearer ${apiKey}`;
+    if (protocol === 'anthropic')
+        headers['anthropic-version'] = '2023-06-01';
+    if (protocol === 'github_models')
+        headers['X-GitHub-Api-Version'] = '2022-11-28';
+    return headers;
+}
+/** Preserve custom gateway prefixes and queries; replace only known endpoints. */
+function providerEndpoint(baseUrl, endpoint) {
+    const url = new URL(baseUrl.trim());
+    const suffix = '/' + endpoint.replace(/^\/+/, '');
+    let base = url.pathname.replace(/\/+$/, '');
+    if (/^\/(?:inference|catalog)\//.test(suffix)) {
+        base = base.replace(/\/(?:inference\/chat\/completions|catalog\/models|inference)$/i, '');
+    }
+    else {
+        base = base.replace(/\/(?:chat\/completions|responses|messages|models)$/i, '');
+    }
+    if (!base && /^(?:api\.openai\.com|api\.anthropic\.com)$/i.test(url.hostname))
+        base = '/v1';
+    url.pathname = base + suffix;
+    url.hash = '';
+    return url.toString();
+}
+//# sourceMappingURL=provider-request-compat.js.map

package/dist/providers/responses.adapter.d.ts

@@ -16,6 +16,8 @@ export declare class ResponsesAdapter implements ModelProviderAdapter {
     execute(request: SerializedProviderRequest, signal: AbortSignal, transport?: typeof defaultProviderTransport): AsyncIterable<NormalizedProviderEvent>;
     private emitNonStreaming;
     normalizeUsage(value: unknown): ActualApiUsage | null;
+    private completionError;
+    private validToolArguments;
     normalizeHeaders(headers: Headers | Record<string, string>): ProviderResponseMetadata;
     private extractResponsesText;
     private extractChatCompletionText;