@oomol-lab/open-connector 1.9.1 → 1.9.3

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

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

package/src/providers/fundable/executors.js

@@ -0,0 +1,74 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { requiredResponseRecord, runProviderRequest, ProviderRequestError, providerInputError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { fundableActions } from "./actions.js";
+import { fundableRoutes } from "./actions.js";
+const fundableApiBaseUrl = "https://www.tryfundable.ai/api/v1";
+async function requestFundable(path, method, parameters, apiKey, fetcher, validating = false, parentSignal) {
+    const url = new URL(`${fundableApiBaseUrl}${path}`);
+    if (method === "GET") {
+        for (const [key, value] of Object.entries(parameters)) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    return runProviderRequest({ label: "fundable", signal: parentSignal }, async (signal) => {
+        const headers = new Headers({ accept: "application/json", authorization: `Bearer ${apiKey}` });
+        if (method === "POST")
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url.toString(), {
+            method,
+            headers,
+            body: method === "POST" ? JSON.stringify(parameters) : undefined,
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, response.ok ? "fundable returned malformed JSON" : `fundable request failed (${response.status})`, undefined, "provider_error");
+        }
+        const object = optionalRecord(payload);
+        if (!response.ok || object?.success === false || object?.error != null) {
+            const error = optionalRecord(object?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message) ??
+                optionalString(object?.error) ??
+                optionalString(object?.message) ??
+                `fundable request failed (${response.status})`;
+            const detail = code ? `${code}: ${message}` : message;
+            if (code === "INVALID_API_KEY" || code === "INACTIVE_API_KEY") {
+                throw new ProviderRequestError(validating ? 400 : 409, detail, undefined, validating ? "invalid_input" : "authorization_failed");
+            }
+            throw new ProviderRequestError(response.ok ? 502 : response.status, detail, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Fundable response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const route = fundableRoutes[actionName];
+    if (!route)
+        throw providerInputError("Unknown action route");
+    const path = route.path.replace("{id}", encodeURIComponent(String(values.id)));
+    const parameters = { ...values };
+    if (route.path.includes("{id}"))
+        delete parameters.id;
+    return requestFundable(path, route.method, parameters, apiKey, fetcher, undefined, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await requestFundable("/industry/search", "GET", { name: "software" }, input.apiKey, fetcher, true, signal);
+        return { profile: { displayName: "Fundable API Key" }, grantedScopes: [], metadata: {} };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("fundable", Object.fromEntries(fundableActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "fundable",
+    baseUrl: fundableApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/fusion-api/runtime.js

@@ -1,9 +1,8 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
 import { compactJson, encodePathSegment } from "../../core/request.js";
-import { createProviderTimeout, isAbortLikeError, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 import { fusionApiOperations } from "./operations.js";
 export const fusionApiDefaultBaseUrl = "https://fusion-api.oomol.com";
-const fusionApiDefaultRequestTimeoutMs = 30_000;
 const fusionApiLongRunningRequestTimeoutMs = 300_000;
 const fusionApiLongRunningPaths = new Set(["/v1/deepseek-ocr/action/recognize", "/v1/jina-reader/action/read"]);
 const fusionApiValidationPath = "/openapi/qwen-image?hideTaskStateAPI=true";
@@ -52,7 +51,7 @@ async function fusionApiRequest(context, request) {
     }
     const requestTimeoutMs = fusionApiLongRunningPaths.has(request.path)
         ? fusionApiLongRunningRequestTimeoutMs
-        : fusionApiDefaultRequestTimeoutMs;
+        : defaultProviderRequestTimeoutMs;
     const timeout = createProviderTimeout(context.signal, requestTimeoutMs);
     let response;
     try {

package/src/providers/gagelist/executors.js

@@ -1,5 +1,5 @@
 import { optionalInteger, optionalRawString, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, providerUserAgent, createProviderTimeout, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, readProviderProxyErrorMessage, readProviderProxyResponse, readProviderTextBody, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, providerUserAgent, createProviderTimeout, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, readProviderProxyErrorMessage, readProviderProxyResponse, readProviderTextBody, requireCustomCredential, toProviderProxyError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "gagelist";
 const gagelistApiBaseUrl = "https://gagelist.net/GageList/api";
 const gagelistTokenUrl = "https://gagelist.net/api/token";
@@ -452,7 +452,7 @@ function listQuery(input) {
 function requireObject(value, message) {
     const object = optionalRecord(value);
     if (!object) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return object;
 }
@@ -480,7 +480,7 @@ function createGagelistError(status, payload, phase, operation) {
         optionalRawString(body?.message) ??
         `GageList ${operation} failed with HTTP ${status}`;
     if (phase == "validate" && (status == 400 || status == 401 || status == 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status == 401 || status == 403) {
         return new ProviderRequestError(status, message);

package/src/providers/gainsight_nxt/executors.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, rawStringOrNull } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, readProviderTextBody, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, readProviderTextBody, requireApiKeyCredential, providerResponseError, } from "../provider-runtime.js";
 const gainsightNxtMaxResponseBytes = 10 * 1024 * 1024;
 const companyPath = "/v1/data/objects/Company";
 const companyQueryPath = "/v1/data/objects/query/Company";
@@ -171,7 +171,7 @@ function createGainsightError(status, payload, phase) {
     if (status >= 400 && status < 500) {
         return new ProviderRequestError(status || 400, message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function readGainsightErrorMessage(payload) {
     if (typeof payload === "string" && payload.trim()) {

package/src/providers/gamma/executors.js

@@ -1,10 +1,9 @@
 import { compactObject, optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { compactJson } from "../../core/request.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, providerUserAgent, requiredInputString, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, ProviderRequestError, providerUserAgent, requiredInputString, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "gamma";
 const gammaApiBaseUrl = "https://public-api.gamma.app";
 const gammaApiVersionPath = "/v1.0";
-const gammaDefaultRequestTimeoutMs = 30_000;
 export const gammaActionHandlers = {
     create_generation(input, context) {
         return createGeneration(input, context);
@@ -215,7 +214,9 @@ function isTerminalGenerationStatus(status) {
     return status === "completed" || status === "failed";
 }
 async function gammaRequest(input) {
-    const requestTimeoutMs = input.timeoutMs == null ? gammaDefaultRequestTimeoutMs : Math.min(gammaDefaultRequestTimeoutMs, input.timeoutMs);
+    const requestTimeoutMs = input.timeoutMs == null
+        ? defaultProviderRequestTimeoutMs
+        : Math.min(defaultProviderRequestTimeoutMs, input.timeoutMs);
     const timeoutSignal = AbortSignal.timeout(requestTimeoutMs);
     const signal = input.context.signal ? AbortSignal.any([input.context.signal, timeoutSignal]) : timeoutSignal;
     const url = new URL(`${gammaApiVersionPath}${input.path}`, gammaApiBaseUrl);

package/src/providers/gangtise/runtime.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const gangtiseApiBaseUrl = "https://openapi.gangtise.com";
 const gangtiseCredentialUrl = "https://open-platform.gangtise.com/";
-const gangtiseRequestTimeoutMs = 30_000;
 const loginPath = "/application/auth/oauth/open/loginV2";
 const securitiesSearchPath = "/application/open-reference/securities/search";
 const realtimeQuotePath = "/application/open-quote/quote/realtime";
@@ -846,7 +845,7 @@ function normalizeMatrix(value, outputFields) {
     });
 }
 async function postGangtiseJson(input) {
-    const timeout = createTimeoutSignal({ timeoutMs: gangtiseRequestTimeoutMs });
+    const timeout = createTimeoutSignal({ timeoutMs: defaultProviderRequestTimeoutMs });
     let response;
     let payload;
     try {
@@ -908,7 +907,7 @@ function createGangtiseError(response, payload, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
     if (response.status === 400 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status >= 500 ? 502 : response.status || 502, message);
 }

package/src/providers/gatherup/runtime.js

@@ -115,7 +115,7 @@ async function readGatherupPayload(response) {
 function createGatherupError(status, payload, phase) {
     const message = extractGatherupErrorMessage(payload) ?? `GatherUp request failed with status ${status}`;
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (status === 401 || status === 403)) {
         return new ProviderRequestError(status, message);

package/src/providers/geckoboard/executors.js

@@ -1,9 +1,8 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
 import { compactJson, jsonObject } from "../../core/request.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "geckoboard";
 const geckoboardApiBaseUrl = "https://api.geckoboard.com";
-const geckoboardDefaultRequestTimeoutMs = 30_000;
 export const geckoboardActionHandlers = {
     async find_or_create_dataset(input, context) {
         const datasetId = readInputString(input.datasetId, "datasetId");
@@ -97,7 +96,7 @@ export const credentialValidators = {
     },
 };
 async function requestGeckoboardJson(input) {
-    const timeoutSignal = AbortSignal.timeout(geckoboardDefaultRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = input.context.signal ? AbortSignal.any([input.context.signal, timeoutSignal]) : timeoutSignal;
     let response;
     let payload;

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

@@ -8,7 +8,6 @@ export declare const geminiDefaultVideoModel = "veo-3.0-generate-001";
 export declare const geminiDefaultVideoPollIntervalMs = 10000;
 export declare const geminiDefaultVideoMaxWaitMs: number;
 export declare const geminiDefaultRequestTimeoutMs = 10000;
-export declare const geminiDefaultLongRunningRequestTimeoutMs = 30000;
 type GeminiErrorMode = "validate" | "execute";
 interface GeminiModelSummary {
     name: string;

package/src/providers/gemini/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
 import { jsonObject, readBoundedResponseBytes } from "../../core/request.js";
-import { isAbortLikeError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const geminiApiBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
 export const geminiDefaultTextModel = "gemini-2.5-flash";
 export const geminiDefaultEmbeddingModel = "text-embedding-004";
@@ -10,7 +10,6 @@ export const geminiDefaultVideoModel = "veo-3.0-generate-001";
 export const geminiDefaultVideoPollIntervalMs = 10_000;
 export const geminiDefaultVideoMaxWaitMs = 12 * 60_000;
 export const geminiDefaultRequestTimeoutMs = 10_000;
-export const geminiDefaultLongRunningRequestTimeoutMs = 30_000;
 export function geminiHeaders(apiKey) {
     return {
         "content-type": "application/json",
@@ -176,7 +175,7 @@ export async function generateGeminiImage(input, context) {
             safetySettings: asSafetySettings(input.safety_settings),
             systemInstruction: buildGeminiSystemInstruction(input.system_instruction),
         })),
-    }, context, "generate_image", resolveGeminiTimeoutMs(input.timeout, geminiDefaultLongRunningRequestTimeoutMs));
+    }, context, "generate_image", resolveGeminiTimeoutMs(input.timeout, defaultProviderRequestTimeoutMs));
     await assertGeminiResponse(response, "execute", "generate_image");
     const payload = await readGeminiJson(response, "generate_image");
     const inlineImage = extractInlineDataPart(payload, "image/");
@@ -215,7 +214,7 @@ export async function generateGeminiVideos(input, context) {
                 seed: optionalInteger(input.seed),
             }),
         })),
-    }, context, "generate_videos", geminiDefaultLongRunningRequestTimeoutMs);
+    }, context, "generate_videos", defaultProviderRequestTimeoutMs);
     await assertGeminiResponse(response, "execute", "generate_videos");
     const payload = await readGeminiJson(response, "generate_videos");
     const operationName = optionalString(payload.name);
@@ -282,7 +281,7 @@ async function fetchGeminiVideoOperation(input, context) {
     const operationName = buildOperationResource(optionalString(input.operation_name) ?? "", resolveGeminiModel(input.model, geminiDefaultVideoModel));
     const response = await fetchGemini(`${geminiApiBaseUrl}/${operationName}`, {
         headers: geminiHeaders(context.apiKey),
-    }, context, "get_videos_operation", geminiDefaultLongRunningRequestTimeoutMs);
+    }, context, "get_videos_operation", defaultProviderRequestTimeoutMs);
     await assertGeminiResponse(response, "execute", "get_videos_operation");
     return readGeminiJson(response, "get_videos_operation");
 }
@@ -432,7 +431,7 @@ async function downloadMediaBytes(url, context) {
     }
     const response = await fetchGemini(url, {
         headers,
-    }, context, "media download", geminiDefaultLongRunningRequestTimeoutMs);
+    }, context, "media download", defaultProviderRequestTimeoutMs);
     if (!response.ok) {
         const message = (await response.text().catch(() => "")) || `gemini media download failed with ${response.status}`;
         throw new ProviderRequestError(502, message, { status: response.status });

package/src/providers/genpage/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, runProviderRequest } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 export const genpageApiBaseUrl = "https://backend.genpage.ai";
 function listHandler(path, outputKey) {
     return async (input, context) => ({
@@ -87,7 +87,7 @@ function createError(status, payload, phase) {
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (phase === "validate" && 400 <= status && status < 500)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     return new ProviderRequestError(status || 500, message);
 }
 function requireArray(value) {

package/src/providers/geokeo/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "geokeo";
 const geokeoApiBaseUrl = "https://geokeo.com";
 const geokeoValidationQuery = "ZZQXV NO MATCH PLACE 19700101";
@@ -104,12 +104,12 @@ function createGeokeoStatusError(status) {
         return new ProviderRequestError(429, status);
     }
     if (status === "INVALID_REQUEST") {
-        return new ProviderRequestError(400, status);
+        return providerInputError(status);
     }
     if (status === "ACCESS_DENIED") {
-        return new ProviderRequestError(400, status);
+        return providerInputError(status);
     }
-    return new ProviderRequestError(502, status);
+    return providerResponseError(status);
 }
 function readGeokeoStatus(payload) {
     return optionalString(payload?.status);

package/src/providers/getnote/runtime.js

@@ -1,7 +1,6 @@
 import { nullableString, optionalNumber, optionalBoolean, optionalRecord, optionalString, requiredRecord, } from "../../core/cast.js";
-import { isAbortLikeError, providerFetch, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { isAbortLikeError, providerFetch, ProviderRequestError, providerUserAgent, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const getnoteBaseUrl = "https://openapi.biji.com";
-const getnoteRequestTimeoutMs = 30_000;
 export async function validateGetnoteCredential(input, fetcher = providerFetch, signal) {
     const apiKey = readGetnoteApiKey(input.apiKey);
     const clientId = readGetnoteClientId(input);
@@ -396,7 +395,7 @@ async function getnoteRequest(context, request) {
             url.searchParams.set(key, String(value));
         }
     }
-    const timeoutSignal = AbortSignal.timeout(getnoteRequestTimeoutMs);
+    const timeoutSignal = AbortSignal.timeout(defaultProviderRequestTimeoutMs);
     const signal = context.signal ? AbortSignal.any([context.signal, timeoutSignal]) : timeoutSignal;
     let response;
     try {

package/src/providers/github/runtime-shared.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalString, optionalRawString } from "../../core/cast.js";
-import { ProviderRequestError } from "../provider-runtime.js";
+import { ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export { compactObject };
 export const githubApiBaseUrl = "https://api.github.com";
 export const githubApiVersion = "2022-11-28";
@@ -135,7 +135,7 @@ export function normalizeGitHubError(response, payload, fallbackMessage) {
         return new ProviderRequestError(404, message);
     }
     if (response.status === 400 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(500, message, response.status);
 }

package/src/providers/glyphic/runtime.js

@@ -1,7 +1,6 @@
 import { compactObject, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const glyphicApiBaseUrl = "https://api.glyphic.ai";
-const glyphicRequestTimeoutMs = 30_000;
 export const glyphicActionHandlers = {
     async list_calls(input, context) {
         const payload = await requestGlyphicJson({
@@ -99,7 +98,7 @@ async function requestGlyphicArray(path, context, label) {
     return readResponseArray(payload, label);
 }
 async function requestGlyphicJson(input, context, mode) {
-    const timeout = createProviderTimeout(context.signal, glyphicRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(buildGlyphicUrl(input.path, input.query), {
             method: input.method,
@@ -121,7 +120,7 @@ async function requestGlyphicJson(input, context, mode) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Glyphic request timed out after ${glyphicRequestTimeoutMs / 1000} seconds`);
+            throw new ProviderRequestError(504, `Glyphic request timed out after ${defaultProviderRequestTimeoutMs / 1000} seconds`);
         }
         const message = error instanceof Error && error.message.trim() ? error.message : "request failed";
         throw new ProviderRequestError(502, `Glyphic request failed: ${message}`);

package/src/providers/gmail/executors.js

@@ -2,7 +2,7 @@ import { format as schemaFormat } from "@cfworker/json-schema";
 import { looseArray, optionalBoolean, optionalNumberLike, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
 import { encodePathSegment } from "../../core/request.js";
 import { googleBearerProxyAuth, googleServiceAccountValidator, resolveGoogleAccessToken, } from "../googledrive/runtime-auth.js";
-import { defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderErrorTextBody, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderErrorTextBody, readProviderJsonBody, readRetryAfterSeconds, requiredInputString, requiredResponseRecord, runProviderRequest, providerRequestErrorCode, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { decodeGmailAttachment } from "./attachment-stream.js";
 import { gmailMaxMimeBytes } from "./limits.js";
 import { assertMatchingReplySubject, buildRecipients, normalizeGmailMessage, normalizeMessageId, normalizeThreadId, readHeader, resolveReplyHeaders, summarizeGmailMessage, } from "./message.js";
@@ -13,6 +13,16 @@ import { gmailMessageReceived } from "./trigger-on-message-received.js";
 const service = "gmail";
 const gmailApiBaseUrl = "https://gmail.googleapis.com/gmail/v1";
 const detailHydrationBatchSize = 10;
+// Hydration fans out one detail request per listed id, which can exceed Gmail's per-user quota.
+// The retry below keeps hydrated rows and paces the rest instead of discarding the page.
+// Six attempts let the backoff climb 1, 2, 4, 8, 16 s (about 31 s of waiting per message at most),
+// long enough for the moving average to drain, without retrying one message forever.
+const hydrationMaxAttempts = 6;
+const hydrationBaseBackoffMs = 1_000;
+// Total time one action may spend waiting out rate limits. It stays well below the few minutes a
+// caller typically allows one action call, so a persistent limit still comes back as rate_limited
+// (which the caller can pace) rather than as a client-side timeout.
+const hydrationRetryBudgetMs = 120_000;
 // Attachments may reach Gmail's 25 MB cap, and the base64 JSON envelope is a third larger again;
 // the default 30 s request budget covers fetch, decode, and disk write, so give this transfer longer.
 const attachmentDownloadTimeoutMs = 120_000;
@@ -49,11 +59,11 @@ export const gmailActionHandlers = {
             })),
         };
     },
-    list_threads(input, { userId, accessToken, fetcher }) {
-        return listThreads(input, userId, accessToken, fetcher);
+    list_threads(input, { userId, accessToken, fetcher, signal }) {
+        return listThreads(input, userId, accessToken, fetcher, signal);
     },
-    fetch_emails(input, { userId, accessToken, fetcher }) {
-        return fetchEmails(input, userId, accessToken, fetcher);
+    fetch_emails(input, { userId, accessToken, fetcher, signal }) {
+        return fetchEmails(input, userId, accessToken, fetcher, signal);
     },
     async get_message(input, { userId, accessToken, fetcher }) {
         const message = await getMessageResource(userId, normalizeMessageId(input.messageId), accessToken, fetcher, "full");
@@ -92,8 +102,8 @@ export const gmailActionHandlers = {
     create_email_draft(input, context) {
         return createEmailDraft(input, context);
     },
-    list_drafts(input, { userId, accessToken, fetcher }) {
-        return listDrafts(input, userId, accessToken, fetcher);
+    list_drafts(input, { userId, accessToken, fetcher, signal }) {
+        return listDrafts(input, userId, accessToken, fetcher, signal);
     },
     get_draft(input, { userId, accessToken, fetcher }) {
         return getDraft(input, userId, accessToken, fetcher);
@@ -233,7 +243,7 @@ export const credentialValidators = {
     },
     customCredential: googleServiceAccountValidator(service, gmailOAuthScopes),
 };
-async function fetchEmails(input, userId, accessToken, fetcher) {
+async function fetchEmails(input, userId, accessToken, fetcher, signal) {
     const detail = trimmedString(input.detail) || "summary";
     const url = new URL(gmailUserUrl(userId, "messages"));
     const query = trimmedString(input.query);
@@ -265,7 +275,7 @@ async function fetchEmails(input, userId, accessToken, fetcher) {
     }
     const includeFullMessage = detail === "full";
     const format = includeFullMessage ? "full" : "metadata";
-    const hydrated = await hydrateInBatches(messages, (message) => getMessageResource(userId, message.id, accessToken, fetcher, format));
+    const hydrated = await hydrateInBatches(messages, (message) => getMessageResource(userId, message.id, accessToken, fetcher, format), signal);
     return {
         messages: hydrated.map((message) => includeFullMessage ? normalizeGmailMessage(message) : summarizeGmailMessage(message)),
         nextPageToken: payload.nextPageToken ?? null,
@@ -285,7 +295,7 @@ async function fetchMessagesByThreadId(input, userId, accessToken, fetcher) {
         messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message)),
     };
 }
-async function listThreads(input, userId, accessToken, fetcher) {
+async function listThreads(input, userId, accessToken, fetcher, signal) {
     const url = new URL(gmailUserUrl(userId, "threads"));
     const query = trimmedString(input.query);
     if (query) {
@@ -300,7 +310,7 @@ async function listThreads(input, userId, accessToken, fetcher) {
     const payload = await fetchJson(url.toString(), accessToken, fetcher);
     const threads = payload.threads ?? [];
     if (input.verbose === true) {
-        const hydrated = await hydrateInBatches(threads, (thread) => getThreadResource(userId, thread.id, accessToken, fetcher, "full"));
+        const hydrated = await hydrateInBatches(threads, (thread) => getThreadResource(userId, thread.id, accessToken, fetcher, "full"), signal);
         return {
             threads: hydrated.map((thread) => ({
                 threadId: thread.id,
@@ -465,7 +475,7 @@ function latestReplyMessage(thread) {
         throw providerInputError("thread has no non-draft messages to reply to");
     return latest;
 }
-async function listDrafts(input, userId, accessToken, fetcher) {
+async function listDrafts(input, userId, accessToken, fetcher, signal) {
     const url = new URL(gmailUserUrl(userId, "drafts"));
     if (input.pageToken != null) {
         url.searchParams.set("pageToken", String(input.pageToken));
@@ -476,7 +486,7 @@ async function listDrafts(input, userId, accessToken, fetcher) {
     const payload = await fetchJson(url.toString(), accessToken, fetcher);
     const drafts = payload.drafts ?? [];
     if (input.verbose === true) {
-        const hydrated = await hydrateInBatches(drafts, (draft) => getDraftResource(userId, draft.id, accessToken, fetcher, "full"));
+        const hydrated = await hydrateInBatches(drafts, (draft) => getDraftResource(userId, draft.id, accessToken, fetcher, "full"), signal);
         return {
             drafts: hydrated.map((draft) => ({
                 id: draft.id,
@@ -780,14 +790,94 @@ function normalizeThread(thread) {
         messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message)),
     };
 }
-async function hydrateInBatches(items, hydrate, batchSize = detailHydrationBatchSize) {
-    const hydrated = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        hydrated.push(...(await Promise.all(batch.map((item) => hydrate(item)))));
+/**
+ * Hydrate every item, in order, or fail the whole call: a caller advances its page cursor on
+ * success, so a partial page must never look complete.
+ *
+ * Items run in batches of up to `detailHydrationBatchSize`. A per-user rate limit on one item
+ * keeps every row already hydrated and requeues only the limited items; the batch width halves
+ * (down to 1) and the next batch waits out `Retry-After` or an exponential, jittered backoff.
+ * Each clean batch widens the next one by a single item again. When an item runs out of
+ * attempts, or the next wait would overrun the action's retry budget, the rate-limit error
+ * with the longest `Retry-After` is thrown unchanged, so the action still reports `rate_limited`.
+ * Any other error rejects immediately, exactly like the plain batch it replaces.
+ */
+async function hydrateInBatches(items, hydrate, signal) {
+    const hydrated = new Array(items.length);
+    const attempts = new Array(items.length).fill(0);
+    const deadline = Date.now() + hydrationRetryBudgetMs;
+    let pending = items.map((_item, index) => index);
+    let width = detailHydrationBatchSize;
+    while (pending.length > 0) {
+        const batch = pending.slice(0, width);
+        const outcomes = await Promise.all(batch.map(async (index) => {
+            attempts[index] += 1;
+            try {
+                hydrated[index] = await hydrate(items[index]);
+                return undefined;
+            }
+            catch (error) {
+                if (isRetryableGmailRateLimit(error))
+                    return error;
+                throw error;
+            }
+        }));
+        const limited = batch.filter((_index, position) => outcomes[position] !== undefined);
+        pending = [...limited, ...pending.slice(batch.length)];
+        if (limited.length === 0) {
+            width = Math.min(detailHydrationBatchSize, width + 1);
+            continue;
+        }
+        // Surface the error carrying the longest Retry-After so the caller can pace the connection.
+        const pacingError = outcomes
+            .filter((error) => error !== undefined)
+            .reduce((longest, error) => (gmailRetryAfterMs(error) > gmailRetryAfterMs(longest) ? error : longest));
+        const attempt = Math.max(...limited.map((index) => attempts[index]));
+        if (attempt >= hydrationMaxAttempts)
+            throw pacingError;
+        const delayMs = hydrationRetryDelayMs(attempt, gmailRetryAfterMs(pacingError));
+        if (Date.now() + delayMs > deadline)
+            throw pacingError;
+        width = Math.max(1, Math.floor(width / 2));
+        await sleepFor(delayMs, signal);
     }
     return hydrated;
 }
+/**
+ * A rate limit worth waiting out inside this action: whatever the runtime reports as `rate_limited`
+ * (any 429, and the 403 rate-limit reasons `readGmailError` labels), except an exhausted daily or
+ * project quota, which stays `rate_limited` but does not recover within one action.
+ */
+function isRetryableGmailRateLimit(error) {
+    return (error instanceof GmailRequestError && !error.quotaExhausted && providerRequestErrorCode(error) === "rate_limited");
+}
+function gmailRetryAfterMs(error) {
+    return (optionalNumberLike(optionalRecord(error.details)?.retryAfterSeconds) ?? 0) * 1_000;
+}
+/** Honour the upstream `Retry-After` when present, else equal-jitter exponential backoff. */
+function hydrationRetryDelayMs(attempt, retryAfterMs) {
+    if (retryAfterMs > 0)
+        return retryAfterMs;
+    const backoffMs = hydrationBaseBackoffMs * 2 ** (attempt - 1);
+    return backoffMs / 2 + Math.random() * (backoffMs / 2);
+}
+function sleepFor(delayMs, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
 function buildLabelPayload(input) {
     return Object.fromEntries(Object.entries(input).filter(([key, value]) => key !== "userId" && key !== "labelId" && value !== undefined));
 }
@@ -864,12 +954,18 @@ async function assertGmailResponse(response) {
     }
     throw await readGmailError(response);
 }
-const gmailQuotaReasons = new Set([
-    "rateLimitExceeded",
-    "userRateLimitExceeded",
-    "dailyLimitExceeded",
-    "quotaExceeded",
-]);
+// Gmail answers both of these with a 403, which would otherwise read as an authorization failure.
+// Per-user rate limits clear within seconds; exhausted daily or project quotas do not.
+const gmailRateLimitReasons = new Set(["rateLimitExceeded", "userRateLimitExceeded"]);
+const gmailExhaustedQuotaReasons = new Set(["dailyLimitExceeded", "quotaExceeded"]);
+/** A Gmail API failure that also records whether the upstream reason was an exhausted quota. */
+class GmailRequestError extends ProviderRequestError {
+    quotaExhausted;
+    constructor(status, message, details, code, quotaExhausted) {
+        super(status, message, details, code);
+        this.quotaExhausted = quotaExhausted;
+    }
+}
 async function readGmailError(response) {
     const text = await readProviderErrorTextBody(response, "gmail error response");
     let error;
@@ -879,8 +975,10 @@ async function readGmailError(response) {
     catch {
         // A malformed response must not expose its raw body or change status classification.
     }
-    const rateLimited = response.status === 403 &&
-        looseArray(error?.errors).some((entry) => gmailQuotaReasons.has(optionalString(optionalRecord(entry)?.reason) ?? ""));
-    return new ProviderRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, withRetryAfterSeconds(response), rateLimited ? "rate_limited" : undefined);
+    const reasons = looseArray(error?.errors).flatMap((entry) => optionalString(optionalRecord(entry)?.reason) ?? []);
+    const quotaExhausted = reasons.some((reason) => gmailExhaustedQuotaReasons.has(reason));
+    const rateLimited = response.status === 403 && (quotaExhausted || reasons.some((reason) => gmailRateLimitReasons.has(reason)));
+    const retryAfterSeconds = rateLimited ? readRetryAfterSeconds(response.headers) : undefined;
+    return new GmailRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, retryAfterSeconds === undefined ? withRetryAfterSeconds(response) : { retryAfterSeconds }, rateLimited ? "rate_limited" : undefined, quotaExhausted);
 }
 export const triggers = [gmailMessageReceived];