@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/googlesheets/trigger-on-row-added.js

@@ -0,0 +1,234 @@
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-row-added.definition.js";
+const permissionMarkers = [
+    "permission_denied",
+    "accessnotconfigured",
+    "insufficientfilepermissions",
+    "appnotauthorizedtofile",
+    "the caller does not have permission",
+    "has not been used in project",
+];
+const quotaMarkers = ["ratelimitexceeded", "dailylimitexceeded"];
+export const googleSheetsRowAdded = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null) {
+            const sheet = await resolveSheet(context, config);
+            return { checkpoint: await anchor(context, config, sheet), events: [] };
+        }
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const sheet = await resolveSheet(context, config);
+        if (checkpoint.spreadsheetId !== config.spreadsheetId || checkpoint.sheetId !== sheet.sheetId) {
+            return { checkpoint: await anchor(context, config, sheet), events: [] };
+        }
+        if (checkpoint.lastRowNumber > sheet.rowCount)
+            return { checkpoint: await anchor(context, config, sheet), events: [] };
+        const headers = await header(context, config, sheet);
+        const start = Math.min(Math.max(config.firstDataRow, checkpoint.lastRowNumber + 1), sheet.rowCount);
+        const end = Math.min(start + Math.min(config.maxRowsPerPoll, maximumPollEventsPerPage) - 1, sheet.rowCount);
+        const rows = await values(context, config, sheet, start, end, "row window fetch");
+        let last = start + rows.length - 1;
+        if (rows.length < end - start + 1) {
+            // API 会省略窗口尾部的空行，确认实际表尾后才能推进游标。
+            const tail = await lastNonEmptyRow(context, config, sheet);
+            if (tail < checkpoint.lastRowNumber)
+                return { checkpoint: { ...checkpoint, lastRowNumber: tail }, events: [] };
+            last = Math.min(end, tail);
+        }
+        if (last <= checkpoint.lastRowNumber)
+            return { checkpoint, events: [] };
+        const events = [];
+        let filtered = 0;
+        for (const [index, cells] of rows.entries()) {
+            const rowNumber = start + index;
+            if (rowNumber <= checkpoint.lastRowNumber)
+                continue;
+            if (rowNumber == config.headerRow || empty(cells)) {
+                filtered += 1;
+                continue;
+            }
+            events.push(await event(config, sheet, rowNumber, cells, headers));
+        }
+        const hasMore = last == end && end < sheet.rowCount;
+        return {
+            checkpoint: {
+                lastRowNumber: last,
+                sheetId: sheet.sheetId,
+                spreadsheetId: config.spreadsheetId,
+            },
+            events,
+            filtered,
+            ...(hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    const range = value.columnRange.trim();
+    const separator = range.indexOf(":");
+    const colStart = separator < 0 ? range : range.slice(0, separator);
+    const colEnd = separator < 0 ? range : range.slice(separator + 1);
+    const spreadsheet = value.spreadsheetId.trim();
+    return {
+        colEnd,
+        colStart,
+        dateTimeRender: value.dateTimeRender,
+        firstDataRow: value.firstDataRow,
+        headerRow: value.headerRow,
+        maxRowsPerPoll: value.maxRowsPerPoll,
+        sheet: value.sheet,
+        spreadsheetId: /\/spreadsheets\/d\/([A-Za-z0-9_-]+)/.exec(spreadsheet)?.[1] ?? spreadsheet,
+        valueRender: value.valueRender,
+    };
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    if (typeof checkpoint?.spreadsheetId != "string" ||
+        !Number.isInteger(checkpoint.sheetId) ||
+        !Number.isInteger(checkpoint.lastRowNumber)) {
+        throw new PermanentPollError("Google Sheets checkpoint is invalid; recreate the Trigger.");
+    }
+    return {
+        lastRowNumber: checkpoint.lastRowNumber,
+        sheetId: checkpoint.sheetId,
+        spreadsheetId: checkpoint.spreadsheetId,
+    };
+}
+async function resolveSheet(context, config) {
+    const result = await get(context, `/spreadsheets/${encodeURIComponent(config.spreadsheetId)}`, {
+        fields: "sheets.properties(sheetId,title,sheetType,gridProperties)",
+    });
+    if (result.status == 404)
+        throw new PermanentPollError("The Google Sheets spreadsheet was not found.");
+    success(result, "spreadsheet metadata fetch");
+    const raw = record(result.data)?.sheets;
+    const properties = Array.isArray(raw)
+        ? raw.map((value) => record(record(value)?.properties))
+        : [];
+    const candidates = properties.filter((value) => value != null);
+    const byId = /^\d+$/.test(config.sheet)
+        ? candidates.find(({ sheetId }) => sheetId === Number(config.sheet))
+        : undefined;
+    const match = byId ?? candidates.find(({ title }) => title === config.sheet);
+    if (match == null)
+        throw new PermanentPollError(`Google Sheets tab "${config.sheet}" does not exist.`);
+    if (match.sheetType != null && match.sheetType !== "GRID")
+        throw new PermanentPollError("The Google Sheets tab is not a grid sheet.");
+    const rowCount = match.gridProperties?.rowCount;
+    if (match.sheetId == null || match.title == null || rowCount == null) {
+        throw new TransientPollError("Google Sheets tab metadata is incomplete.");
+    }
+    return { rowCount, sheetId: match.sheetId, title: match.title };
+}
+async function anchor(context, config, sheet) {
+    return {
+        lastRowNumber: await lastNonEmptyRow(context, config, sheet),
+        sheetId: sheet.sheetId,
+        spreadsheetId: config.spreadsheetId,
+    };
+}
+async function lastNonEmptyRow(context, config, sheet) {
+    if (sheet.rowCount < config.firstDataRow)
+        return config.firstDataRow - 1;
+    const rows = await values(context, config, sheet, config.firstDataRow, sheet.rowCount, "full-range scan");
+    return rows.length == 0 ? config.firstDataRow - 1 : config.firstDataRow + rows.length - 1;
+}
+async function header(context, config, sheet) {
+    const result = await get(context, valuesEndpoint(config, sheet, config.headerRow, config.headerRow), {
+        majorDimension: "ROWS",
+        valueRenderOption: "FORMATTED_VALUE",
+    });
+    success(result, "header row fetch");
+    return readValues(result.data)[0] ?? [];
+}
+async function values(context, config, sheet, start, end, operation) {
+    const result = await get(context, valuesEndpoint(config, sheet, start, end), {
+        dateTimeRenderOption: config.dateTimeRender,
+        majorDimension: "ROWS",
+        valueRenderOption: config.valueRender,
+    });
+    success(result, operation);
+    return readValues(result.data);
+}
+function readValues(data) {
+    const rows = record(data)?.values;
+    return Array.isArray(rows) ? rows : [];
+}
+function empty(cells) {
+    return cells.every((cell) => cell === "" || cell == null);
+}
+async function event(config, sheet, rowNumber, cells, headers) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(cells)));
+    const hash = [...new Uint8Array(digest)]
+        .slice(0, 8)
+        .map((value) => value.toString(16).padStart(2, "0"))
+        .join("");
+    const row = {};
+    const start = columnNumber(config.colStart);
+    for (const [index, cell] of cells.entries()) {
+        const heading = headers[index];
+        row[typeof heading == "string" && heading.length > 0 ? heading : columnLetters(start + index)] = cell;
+    }
+    return {
+        dedupeKey: `${sheet.sheetId}:${rowNumber}:${hash}`,
+        payload: {
+            row,
+            rowNumber,
+            sheetId: sheet.sheetId,
+            sheetTitle: sheet.title,
+            spreadsheetId: config.spreadsheetId,
+            values: cells,
+        },
+    };
+}
+function valuesEndpoint(config, sheet, start, end) {
+    const title = encodeURIComponent(`'${sheet.title.replaceAll("'", "''")}'`);
+    return `/spreadsheets/${encodeURIComponent(config.spreadsheetId)}/values/${title}!${config.colStart}${start}:${config.colEnd}${end}`;
+}
+async function get(context, endpoint, query) {
+    try {
+        return await context.connector.execute({ endpoint, method: "GET", query }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Google Sheets proxy request to ${endpoint} failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401)
+        throw new PollConnectionError(`Google Sheets ${operation} rejected the Connection.`);
+    const haystack = JSON.stringify(result.data ?? null).toLowerCase();
+    if (result.status == 403) {
+        if (quotaMarkers.some((marker) => haystack.includes(marker)))
+            throw new TransientPollError(`Google Sheets ${operation} was rate limited.`);
+        if (permissionMarkers.some((marker) => haystack.includes(marker))) {
+            throw new PollConnectionError(`Google Sheets ${operation} rejected the Connection.`);
+        }
+    }
+    if (result.status == 400 && haystack.includes("unable to parse range")) {
+        throw new PermanentPollError("Google Sheets rejected the configured range.");
+    }
+    if (result.status == 413)
+        throw new PermanentPollError("Google Sheets response is too large; narrow columnRange.");
+    throw new TransientPollError(`Google Sheets ${operation} failed with status ${result.status}.`);
+}
+function columnNumber(letters) {
+    let value = 0;
+    for (const letter of letters.toUpperCase())
+        value = value * 26 + letter.charCodeAt(0) - 64;
+    return value;
+}
+function columnLetters(value) {
+    let letters = "";
+    for (let rest = value; rest > 0; rest = Math.floor((rest - 1) / 26)) {
+        letters = String.fromCharCode(65 + ((rest - 1) % 26)) + letters;
+    }
+    return letters;
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/googleslides/executors.js

@@ -1,6 +1,6 @@
 import { compactObject, objectArray, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest } from "../google-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
 import { defineProviderProxy, providerInputError, ProviderRequestError } from "../provider-runtime.js";
 import { googleSlidesOAuthScopes } from "./scopes.js";
 export const slidesApiBaseUrl = "https://slides.googleapis.com/v1";

package/src/providers/googleslides/scopes.d.ts

@@ -2,9 +2,6 @@ export declare const presentationsReadonlyScope = "https://www.googleapis.com/au
 export declare const presentationsScope = "https://www.googleapis.com/auth/presentations";
 export declare const googleDriveReadonlyScope = "https://www.googleapis.com/auth/drive.readonly";
 export declare const googleDriveFullScope = "https://www.googleapis.com/auth/drive";
-export declare const googleOpenIdScope = "openid";
-export declare const googleEmailScope = "email";
-export declare const googleProfileScope = "profile";
 export declare const googleSlidesReadScopes: string[];
 export declare const googleSlidesWriteScopes: string[];
 export declare const googleSlidesOAuthScopes: string[];

package/src/providers/googleslides/scopes.js

@@ -1,10 +1,8 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const presentationsReadonlyScope = "https://www.googleapis.com/auth/presentations.readonly";
 export const presentationsScope = "https://www.googleapis.com/auth/presentations";
 export const googleDriveReadonlyScope = "https://www.googleapis.com/auth/drive.readonly";
 export const googleDriveFullScope = "https://www.googleapis.com/auth/drive";
-export const googleOpenIdScope = "openid";
-export const googleEmailScope = "email";
-export const googleProfileScope = "profile";
 export const googleSlidesReadScopes = [presentationsReadonlyScope, googleDriveReadonlyScope];
 export const googleSlidesWriteScopes = [presentationsScope, googleDriveFullScope];
 export const googleSlidesOAuthScopes = [
@@ -12,7 +10,5 @@ export const googleSlidesOAuthScopes = [
     presentationsScope,
     googleDriveReadonlyScope,
     googleDriveFullScope,
-    googleOpenIdScope,
-    googleEmailScope,
-    googleProfileScope,
+    ...googleIdentityScopes,
 ];

package/src/providers/googletasks/executors.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalRecord, optionalString, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { googleTasksOAuthScopes } from "./scopes.js";
 export const googleTasksApiBaseUrl = "https://tasks.googleapis.com/tasks/v1";

package/src/providers/googletasks/scopes.d.ts

@@ -1,8 +1,5 @@
 export declare const googleTasksReadonlyScope = "https://www.googleapis.com/auth/tasks.readonly";
 export declare const googleTasksFullScope = "https://www.googleapis.com/auth/tasks";
-export declare const googleOpenIdScope = "openid";
-export declare const googleEmailScope = "email";
-export declare const googleProfileScope = "profile";
 export declare const googleTasksReadScopes: string[];
 export declare const googleTasksWriteScopes: string[];
 export declare const googleTasksOAuthScopes: string[];

package/src/providers/googletasks/scopes.js

@@ -1,14 +1,10 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const googleTasksReadonlyScope = "https://www.googleapis.com/auth/tasks.readonly";
 export const googleTasksFullScope = "https://www.googleapis.com/auth/tasks";
-export const googleOpenIdScope = "openid";
-export const googleEmailScope = "email";
-export const googleProfileScope = "profile";
 export const googleTasksReadScopes = [googleTasksReadonlyScope];
 export const googleTasksWriteScopes = [googleTasksFullScope];
 export const googleTasksOAuthScopes = [
     googleTasksReadonlyScope,
     googleTasksFullScope,
-    googleOpenIdScope,
-    googleEmailScope,
-    googleProfileScope,
+    ...googleIdentityScopes,
 ];

package/src/providers/granola/actions.js

@@ -67,6 +67,8 @@ const noteSchema = s.looseObject("A Granola note object. MCP supplies ID, title,
     summary_text: s.string("The plain text summary of the note."),
     summary_markdown: s.nullable(s.string("The markdown summary of the note, when available.")),
     transcript: s.nullable(s.array("Transcript items returned by Granola.", transcriptItemSchema)),
+    date: s.optional(s.string("MCP only: meeting date when available, not a creation or update timestamp.")),
+    participants: s.optional(s.string("MCP only: participant names and email addresses as Granola lists them.")),
 });
 const listNotesInputSchema = s.object("Query parameters for listing Granola notes.", {
     created_before: dateOrDateTimeSchema,

package/src/providers/granola/runtime-mcp.js

@@ -30,6 +30,8 @@ export const granolaMcpActionHandlers = {
                 title: meeting.title,
                 summary_markdown: meeting.summary,
                 transcript: input.include === "transcript" ? [{ text: await getGranolaTranscript(context, id) }] : undefined,
+                date: meeting.date,
+                participants: meeting.attendees || undefined,
             },
         };
     },

package/src/providers/granola/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, objectArray, optionalRawString, optionalRecord, optionalString, rawStringOrNull, requiredBoolean, requiredRawString, requiredString, requiredStringArray, } from "../../core/cast.js";
-import { providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
 export const granolaApiBaseUrl = "https://public-api.granola.ai";
 export const granolaActionHandlers = {
     async list_notes(input, context) {
@@ -190,5 +190,5 @@ async function assertGranolaResponse(response, mode) {
     if (response.status === 400 || response.status === 404 || response.status === 422) {
         throw new ProviderRequestError(400, message);
     }
-    throw new ProviderRequestError(response.status >= 500 ? 502 : response.status || 502, message);
+    throw new ProviderRequestError(response.status >= 500 ? 502 : response.status || 502, message, withRetryAfterSeconds(response));
 }

package/src/providers/hithink_finance/runtime.js

@@ -393,7 +393,7 @@ function getPool(get, path, input, context) {
 function getFinancialStatements(path, input, context) {
     return get(path, {
         thscode: requiredInputString(input.thscode, "thscode"),
-        period: optionalString(input.period),
+        period: optionalString(input.period) ?? "annual",
         limit: optionalNumber(input.limit),
         start: optionalNumber(input.startTimeMs),
         end: optionalNumber(input.endTimeMs),

package/src/providers/indexed/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/indexed/executors.js

@@ -0,0 +1,16 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { indexedActionHandlers, indexedApiBaseUrl, readIndexedError, validateIndexedCredential } from "./runtime.js";
+const service = "indexed";
+export const executors = defineApiKeyProviderExecutors(service, indexedActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: indexedApiBaseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    readError: readIndexedError,
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    apiKey: validateIndexedCredential,
+};

package/src/providers/indexed/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers } from "../provider-runtime.ts";
+import { ProviderRequestError } from "../provider-runtime.ts";
+export declare const indexedApiBaseUrl = "https://indexed.vc/api/v1";
+type IndexedPhase = "validate" | "execute";
+type IndexedActionHandler = (input: Record<string, unknown>, context: ApiKeyProviderContext) => Promise<unknown>;
+export declare const indexedActionHandlers: ProviderActionHandlers<"indexed", IndexedActionHandler>;
+/**
+ * Validate a key with GET /usage, which the API documents as free of credit charges.
+ */
+export declare function validateIndexedCredential(input: {
+    apiKey: string;
+}, options: {
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;
+/**
+ * Read an Indexed error response and map it onto the runtime's status conventions.
+ * 402 is a billing state (credits exhausted), reported as insufficient_credit.
+ * 403 TIER_UPGRADE_REQUIRED is a plan limit rather than a credential failure, so
+ * it is reported as invalid input instead of prompting a reconnect. During key
+ * validation a 401 or 403 is a field error on the submitted key. Every other
+ * status keeps its upstream value, so a 404 stays a not-found result.
+ */
+export declare function readIndexedError(response: Response, phase?: IndexedPhase): Promise<ProviderRequestError>;
+export {};

package/src/providers/indexed/runtime.js

@@ -0,0 +1,129 @@
+import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment, queryParams } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerUserAgent, ProviderRequestError, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const indexedApiBaseUrl = "https://indexed.vc/api/v1";
+export const indexedActionHandlers = {
+    lookup_company_by_domain(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: { domain: requiredInputString(input.domain, "domain") },
+        });
+    },
+    lookup_companies_by_domains(input, context) {
+        return requestIndexed({ context, path: "/companies/lookup", body: { domains: input.domains } });
+    },
+    search_companies(input, context) {
+        return requestIndexed({
+            context,
+            path: "/companies",
+            query: {
+                q: optionalString(input.q),
+                industries: joinList(input.industries),
+                countries: joinList(input.countries),
+                employees: joinList(input.employees),
+                operatingStatus: joinList(input.operatingStatus),
+                minFunding: optionalInteger(input.minFunding),
+                maxFunding: optionalInteger(input.maxFunding),
+                minCompleteness: optionalInteger(input.minCompleteness),
+                updated_since: optionalString(input.updatedSince),
+                reveal_status: optionalString(input.revealStatus),
+                sort: optionalString(input.sort),
+                order: optionalString(input.order),
+                page: optionalInteger(input.page),
+                limit: optionalInteger(input.limit),
+                cursor: optionalString(input.cursor),
+            },
+        });
+    },
+    get_company(input, context) {
+        return requestIndexed({
+            context,
+            path: `/companies/${encodePathSegment(requiredInputString(input.slug, "slug"))}`,
+            query: { depth: optionalString(input.depth) },
+        });
+    },
+};
+/**
+ * Validate a key with GET /usage, which the API documents as free of credit charges.
+ */
+export async function validateIndexedCredential(input, options) {
+    const payload = await requestIndexed({
+        context: { apiKey: input.apiKey, fetcher: options.fetcher, signal: options.signal },
+        path: "/usage",
+        phase: "validate",
+    });
+    const usage = optionalRecord(payload.data);
+    const tier = optionalString(usage?.tier);
+    return {
+        profile: {
+            accountId: "indexed",
+            displayName: tier ? `Indexed API Key (${tier} plan)` : "Indexed API Key",
+        },
+        grantedScopes: [],
+        metadata: compactObject({
+            apiBaseUrl: indexedApiBaseUrl,
+            validationEndpoint: "/usage",
+            tier,
+            creditsRemaining: optionalInteger(usage?.credits_remaining),
+        }),
+    };
+}
+function joinList(value) {
+    return Array.isArray(value) && value.length > 0 ? value.join(",") : undefined;
+}
+async function requestIndexed(input) {
+    const { context } = input;
+    const url = new URL(`${indexedApiBaseUrl}${input.path}`);
+    for (const [key, value] of Object.entries(queryParams(input.query ?? {}))) {
+        url.searchParams.set(key, value);
+    }
+    return runProviderRequest({ signal: context.signal, label: "Indexed" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: input.body ? "POST" : "GET",
+            headers: compactObject({
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+                "x-api-key": context.apiKey,
+                "content-type": input.body ? "application/json" : undefined,
+            }),
+            body: input.body ? JSON.stringify(input.body) : undefined,
+            signal,
+        });
+        if (!response.ok) {
+            throw await readIndexedError(response, input.phase ?? "execute");
+        }
+        const payload = parseProviderJsonBodyText(await readProviderTextBody(response, "Indexed response"), {
+            emptyBody: {},
+            invalidJsonMessage: "Indexed returned malformed JSON",
+        });
+        return requiredResponseRecord(payload, "Indexed response");
+    });
+}
+/**
+ * Read an Indexed error response and map it onto the runtime's status conventions.
+ * 402 is a billing state (credits exhausted), reported as insufficient_credit.
+ * 403 TIER_UPGRADE_REQUIRED is a plan limit rather than a credential failure, so
+ * it is reported as invalid input instead of prompting a reconnect. During key
+ * validation a 401 or 403 is a field error on the submitted key. Every other
+ * status keeps its upstream value, so a 404 stays a not-found result.
+ */
+export async function readIndexedError(response, phase = "execute") {
+    const status = response.status;
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "Indexed error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "Indexed returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const body = optionalRecord(payload);
+    const message = optionalString(body?.error) ?? `Indexed request failed with HTTP ${status}`;
+    const details = withRetryAfterSeconds(response, payload);
+    if (status === 402) {
+        return new ProviderRequestError(402, message, details, "insufficient_credit");
+    }
+    if ((status === 401 || status === 403) &&
+        (phase === "validate" || optionalString(body?.code) === "TIER_UPGRADE_REQUIRED")) {
+        return new ProviderRequestError(400, message, details);
+    }
+    return new ProviderRequestError(status, message, details);
+}

package/src/providers/indiegogo/executors.js

@@ -10,7 +10,7 @@ async function execute(input, context, name, path) {
         url.searchParams.set("urlName", String(input.urlName));
     const response = await context.fetcher(url, {
         headers: { accept: "application/json", "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
     });
     const payload = await response.json().catch(() => null);
     if (!response.ok)

package/src/providers/investoday_mcp/executors.js

@@ -31,7 +31,7 @@ export const proxy = defineProviderProxy({
     baseUrl: endpoint,
     auth: { type: "api_key_query", name: "apiKey" },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     allowedEndpoint(value) {
         const url = new URL(value, endpoint);
         return url.origin === "https://data-api.investoday.net" && url.pathname === "/data/mcp";
@@ -62,7 +62,7 @@ function connectionInput(key, fetcher, signal) {
         service: "Investoday",
         fetcher: createInvestodayFetch(fetcher, key),
         signal,
-        redirect: "error",
+        redirect: "manual",
         terminateSession: true,
     };
 }

package/src/providers/iyunbiao/runtime.js

@@ -55,7 +55,7 @@ async function jsonRequest(credentials, fetcher, path, body, token, parentSignal
             headers: buildIyunbiaoHeaders(credentials, token),
             body,
             signal,
-            redirect: "error",
+            redirect: "manual",
         });
         return readJson(response);
     });
@@ -185,7 +185,7 @@ export async function executeIyunbiaoAction(name, input, values, options) {
                 const response = await session.fetcher(`${session.credentials.baseUrl}/${template}/${name === "download_cloud_file" ? `fileBox/${cloudId}` : `file/${input.fileId}`}`, {
                     headers: buildIyunbiaoHeaders(session.credentials, session.token),
                     signal,
-                    redirect: "error",
+                    redirect: "manual",
                 });
                 if (!response.ok)
                     await readJson(response);

package/src/providers/keepa/actions.d.ts

@@ -1,5 +1,5 @@
 import type { ActionDefinition } from "../../core/types.ts";
 export declare const keepaMarketplaces: readonly ["US", "GB", "DE", "FR", "JP", "CA", "IT", "ES", "IN", "MX", "BR"];
 export declare const keepaHistoryTypes: readonly ["AMAZON", "NEW", "USED", "SALES", "LISTPRICE", "COLLECTIBLE", "REFURBISHED", "NEW_FBM_SHIPPING", "LIGHTNING_DEAL", "WAREHOUSE", "NEW_FBA", "COUNT_NEW", "COUNT_USED", "COUNT_REFURBISHED", "COUNT_COLLECTIBLE", "EXTRA_INFO_UPDATES", "RATING", "COUNT_REVIEWS", "BUY_BOX_SHIPPING", "USED_NEW_SHIPPING", "USED_VERY_GOOD_SHIPPING", "USED_GOOD_SHIPPING", "USED_ACCEPTABLE_SHIPPING", "COLLECTIBLE_NEW_SHIPPING", "COLLECTIBLE_VERY_GOOD_SHIPPING", "COLLECTIBLE_GOOD_SHIPPING", "COLLECTIBLE_ACCEPTABLE_SHIPPING", "REFURBISHED_SHIPPING", "EBAY_NEW_SHIPPING", "EBAY_USED_SHIPPING", "TRADE_IN", "RENT", "BUY_BOX_USED_SHIPPING", "PRIME_EXCL", "COUNT_NEW_FBA", "COUNT_NEW_FBM"];
-export declare const keepaDealPriceTypes: readonly ["AMAZON", "NEW", "USED", "SALES", "COLLECTIBLE", "REFURBISHED", "NEW_FBM_SHIPPING", "LIGHTNING_DEAL", "WAREHOUSE", "NEW_FBA", "USED_NEW_SHIPPING", "USED_VERY_GOOD_SHIPPING", "USED_GOOD_SHIPPING", "USED_ACCEPTABLE_SHIPPING", "COLLECTIBLE_NEW_SHIPPING", "COLLECTIBLE_VERY_GOOD_SHIPPING", "COLLECTIBLE_GOOD_SHIPPING", "COLLECTIBLE_ACCEPTABLE_SHIPPING", "REFURBISHED_SHIPPING", "BUY_BOX_USED_SHIPPING", "PRIME_EXCL"];
+export declare const keepaDealPriceTypes: readonly ["AMAZON", "NEW", "USED", "SALES", "COLLECTIBLE", "REFURBISHED", "NEW_FBM_SHIPPING", "LIGHTNING_DEAL", "WAREHOUSE", "NEW_FBA", "BUY_BOX_SHIPPING", "USED_NEW_SHIPPING", "USED_VERY_GOOD_SHIPPING", "USED_GOOD_SHIPPING", "USED_ACCEPTABLE_SHIPPING", "REFURBISHED_SHIPPING", "BUY_BOX_USED_SHIPPING", "PRIME_EXCL"];
 export declare const keepaActions: ActionDefinition[];