@agent-native/core 0.49.25 → 0.49.27

package/dist/provider-api/index.js

@@ -333,6 +333,24 @@ const PROVIDER_CONFIGS = {
                 path: "/calls/transcript",
                 body: { filter: { callIds: ["<call-id>"] } },
             },
+            {
+                label: "Calls with parties/content",
+                method: "POST",
+                path: "/calls/extensive",
+                body: {
+                    filter: { fromDateTime: "<iso-date-time>" },
+                    contentSelector: {
+                        exposedFields: {
+                            parties: true,
+                            content: { brief: true, keyPoints: true },
+                        },
+                    },
+                },
+            },
+        ],
+        notes: [
+            "For broad corpus work, call /calls/extensive with provider-api-request and stageAs/saveToFile. Gong returns the next cursor at records.cursor and expects the next cursor in the POST body at cursor, so use pagination { nextCursorPath: 'records.cursor', cursorBodyPath: 'cursor' } for stageAs or fetchAllPages { cursorPath: 'records.cursor', cursorBodyPath: 'cursor' } for saveToFile.",
+            "Batch transcripts with POST /calls/transcript and body { filter: { callIds: [...] } } after narrowing or staging call ids.",
         ],
     },
     google_calendar: {
@@ -827,9 +845,9 @@ export async function executeProviderApiRequest(args, runtime) {
     // --- fetchAllPages mode ---
     if (args.fetchAllPages) {
         const pageCfg = args.fetchAllPages;
-        const { items, pageCount, lastStatus, lastContentType } = await fetchAllPages(pageCfg, async (extraQuery) => {
-            const queryWithCursor = extraQuery
-                ? mergeQueryObjects(substituteUnknown(args.query, placeholders), extraQuery)
+        const { items, pageCount, lastStatus, lastContentType } = await fetchAllPages(pageCfg, async (extra) => {
+            const queryWithCursor = extra?.query
+                ? mergeQueryObjects(substituteUnknown(args.query, placeholders), extra.query)
                 : substituteUnknown(args.query, placeholders);
             const pageUrl = buildProviderUrl({
                 config,
@@ -837,7 +855,10 @@ export async function executeProviderApiRequest(args, runtime) {
                 rawPath: substituteString(args.path, placeholders),
                 query: queryWithCursor,
             });
-            const pageBody = prepareBody(substituteUnknown(args.body, placeholders), { ...headers });
+            const bodyWithCursor = extra?.bodyCursor
+                ? setValueAtPath(substituteUnknown(args.body, placeholders), extra.bodyCursor.path, extra.bodyCursor.value)
+                : substituteUnknown(args.body, placeholders);
+            const pageBody = prepareBody(bodyWithCursor, { ...headers });
             const resp = await fetchWithTimeout(pageUrl.href, {
                 method,
                 headers,
@@ -960,9 +981,9 @@ async function executeCustomProviderApiRequest(args, customConfig, runtime) {
     // --- fetchAllPages mode (same cursor pagination as built-in providers) ---
     if (args.fetchAllPages) {
         const pageCfg = args.fetchAllPages;
-        const { items, pageCount, lastStatus, lastContentType } = await fetchAllPages(pageCfg, async (extraQuery) => {
-            const queryWithCursor = extraQuery
-                ? mergeQueryObjects(args.query, extraQuery)
+        const { items, pageCount, lastStatus, lastContentType } = await fetchAllPages(pageCfg, async (extra) => {
+            const queryWithCursor = extra?.query
+                ? mergeQueryObjects(args.query, extra.query)
                 : args.query;
             const pageUrl = buildProviderUrl({
                 config: syntheticConfig,
@@ -970,7 +991,10 @@ async function executeCustomProviderApiRequest(args, customConfig, runtime) {
                 rawPath: args.path,
                 query: queryWithCursor,
             });
-            const pageBody = prepareBody(args.body, { ...headers });
+            const bodyWithCursor = extra?.bodyCursor
+                ? setValueAtPath(args.body, extra.bodyCursor.path, extra.bodyCursor.value)
+                : args.body;
+            const pageBody = prepareBody(bodyWithCursor, { ...headers });
             const resp = await fetchWithTimeout(pageUrl.href, {
                 method,
                 headers,
@@ -1413,6 +1437,13 @@ function joinProviderUrlPath(base, rawPath) {
     const providerPath = rawPath.replace(/^\/+/, "");
     if (!providerPath)
         return basePath || "/";
+    const baseSegments = basePath.split("/").filter(Boolean);
+    const providerSegments = providerPath.split("/").filter(Boolean);
+    if (baseSegments.length > 0 &&
+        providerSegments.length >= baseSegments.length &&
+        baseSegments.every((segment, index) => segment === providerSegments[index])) {
+        return `/${providerPath}`;
+    }
     return `${basePath}/${providerPath}`;
 }
 function isAllowedProviderUrl(url, base, config) {
@@ -1828,11 +1859,14 @@ function prepareBody(body, headers) {
 }
 async function fetchWithTimeout(optionsUrl, options) {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), clampTimeout(options.timeoutMs));
+    const timeoutMs = clampTimeout(options.timeoutMs);
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const method = options.method ?? "GET";
+    const secretValues = options.secretValues ?? [];
     try {
         const dispatcher = (await createSsrfSafeDispatcher()) ?? undefined;
         const fetchOptions = {
-            method: options.method ?? "GET",
+            method,
             headers: options.headers,
             body: options.body,
             signal: controller.signal,
@@ -1840,30 +1874,93 @@ async function fetchWithTimeout(optionsUrl, options) {
         };
         if (dispatcher)
             fetchOptions.dispatcher = dispatcher;
-        const startedAt = Date.now();
-        const res = await fetch(optionsUrl, fetchOptions);
-        const elapsedMs = Date.now() - startedAt;
-        const rawText = await readResponseTextWithLimit(res, clampMaxBytes(options.maxBytes));
-        const secretValues = options.secretValues ?? [];
-        const redactedText = redactString(rawText.text, secretValues);
-        const parsed = tryParseJson(redactedText);
-        return {
-            status: res.status,
-            statusText: res.statusText,
-            ok: res.ok,
-            elapsedMs,
-            headers: redactSecrets(headersToObject(res.headers), secretValues),
-            contentType: res.headers.get("content-type") ?? null,
-            size: rawText.size,
-            truncated: rawText.truncated,
-            text: parsed === undefined ? redactedText : undefined,
-            json: parsed,
-        };
+        try {
+            return await fetchProviderResponse(optionsUrl, fetchOptions, {
+                maxBytes: options.maxBytes,
+                secretValues,
+            });
+        }
+        catch (error) {
+            if (dispatcher && isDispatcherCompatibilityError(error)) {
+                const fallbackOptions = { ...fetchOptions };
+                delete fallbackOptions.dispatcher;
+                return await fetchProviderResponse(optionsUrl, fallbackOptions, {
+                    maxBytes: options.maxBytes,
+                    secretValues,
+                });
+            }
+            throw error;
+        }
+    }
+    catch (error) {
+        throw normalizeFetchError(error, {
+            method,
+            url: optionsUrl,
+            timeoutMs,
+            secretValues,
+        });
     }
     finally {
         clearTimeout(timeout);
     }
 }
+async function fetchProviderResponse(url, fetchOptions, options) {
+    const startedAt = Date.now();
+    const res = await fetch(url, fetchOptions);
+    const elapsedMs = Date.now() - startedAt;
+    const rawText = await readResponseTextWithLimit(res, clampMaxBytes(options.maxBytes));
+    const redactedText = redactString(rawText.text, options.secretValues);
+    const parsed = tryParseJson(redactedText);
+    return {
+        status: res.status,
+        statusText: res.statusText,
+        ok: res.ok,
+        elapsedMs,
+        headers: redactSecrets(headersToObject(res.headers), options.secretValues),
+        contentType: res.headers.get("content-type") ?? null,
+        size: rawText.size,
+        truncated: rawText.truncated,
+        text: parsed === undefined ? redactedText : undefined,
+        json: parsed,
+    };
+}
+function isDispatcherCompatibilityError(error) {
+    const err = error;
+    const code = typeof err?.cause?.code === "string" ? err.cause.code : "";
+    const detail = [
+        typeof err?.message === "string" ? err.message : "",
+        typeof err?.cause?.message === "string" ? err.cause.message : "",
+    ]
+        .join(" ")
+        .toLowerCase();
+    return (code === "UND_ERR_INVALID_ARG" &&
+        detail.includes("invalid onrequeststart method"));
+}
+function normalizeFetchError(error, options) {
+    const target = describeProviderRequestTarget(options.url, options.secretValues);
+    const err = error;
+    if (err?.name === "AbortError") {
+        return new Error(`Provider API request timed out after ${options.timeoutMs}ms: ${options.method} ${target}`, { cause: error });
+    }
+    const causeCode = typeof err?.cause?.code === "string" && err.cause.code
+        ? ` (${err.cause.code})`
+        : "";
+    const detail = typeof err?.cause?.message === "string" && err.cause.message
+        ? err.cause.message
+        : typeof err?.message === "string" && err.message
+            ? err.message
+            : String(error);
+    return new Error(`Provider API request failed${causeCode}: ${options.method} ${target}: ${redactString(detail, options.secretValues)}`, { cause: error });
+}
+function describeProviderRequestTarget(rawUrl, secretValues) {
+    try {
+        const url = new URL(rawUrl);
+        return redactString(`${url.host}${url.pathname}${url.search}`, secretValues);
+    }
+    catch {
+        return redactString(rawUrl, secretValues);
+    }
+}
 async function readResponseTextWithLimit(response, maxBytes) {
     const contentLength = response.headers.get("content-length");
     if (contentLength && Number(contentLength) > maxBytes) {
@@ -1945,6 +2042,25 @@ function mergeQueryObjects(base, extra) {
     }
     return extra;
 }
+function setValueAtPath(base, path, value) {
+    const root = base && typeof base === "object" && !Array.isArray(base)
+        ? { ...base }
+        : {};
+    const parts = path.split(".").filter(Boolean);
+    if (!parts.length)
+        return root;
+    let current = root;
+    for (const part of parts.slice(0, -1)) {
+        const existing = current[part];
+        const next = existing && typeof existing === "object" && !Array.isArray(existing)
+            ? { ...existing }
+            : {};
+        current[part] = next;
+        current = next;
+    }
+    current[parts[parts.length - 1]] = value;
+    return root;
+}
 function clampTimeout(timeoutMs) {
     if (!Number.isFinite(timeoutMs))
         return DEFAULT_TIMEOUT_MS;
@@ -2012,14 +2128,29 @@ async function fetchAllPages(config, executeOnePage) {
     let pageCount = 0;
     let lastStatus = 0;
     let lastContentType = null;
+    if (!config.cursorParam && !config.cursorBodyPath) {
+        throw new Error("fetchAllPages requires cursorParam or cursorBodyPath to send the next cursor.");
+    }
+    if (config.cursorParam && config.cursorBodyPath) {
+        throw new Error("fetchAllPages accepts exactly one cursor method: cursorParam or cursorBodyPath.");
+    }
     while (pageCount < maxPages) {
-        const extraQuery = {};
-        if (cursor)
-            extraQuery[config.cursorParam] = cursor;
-        const page = await executeOnePage(pageCount > 0 ? extraQuery : undefined);
+        const extra = {};
+        if (cursor) {
+            if (config.cursorParam)
+                extra.query = { [config.cursorParam]: cursor };
+            if (config.cursorBodyPath) {
+                extra.bodyCursor = { path: config.cursorBodyPath, value: cursor };
+            }
+        }
+        const page = await executeOnePage(pageCount > 0 ? extra : undefined);
         lastStatus = page.status;
         lastContentType = page.contentType;
         pageCount++;
+        if (!page.ok) {
+            const preview = page.text.replace(/\s+/g, " ").trim().slice(0, 500);
+            throw new Error(`fetchAllPages request failed with HTTP ${page.status}${preview ? `: ${preview}` : ""}`);
+        }
         let body;
         try {
             body = JSON.parse(page.text);