@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/tinyfish/research-schemas.js

@@ -0,0 +1,71 @@
+import { s } from "../../core/json-schema.js";
+export const researchStatus = s.stringEnum("Research run state.", [
+    "RUNNING",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED",
+    "TIMED_OUT",
+    "QUEUED",
+]);
+export const researchId = s.string("Research run identifier.", { minLength: 1 });
+export const researchInput = {
+    ...s.object("Asynchronous research parameters.", {
+        query: s.string("Research question.", { minLength: 1, maxLength: 2000 }),
+        mode: s.stringEnum("Research depth; defaults to deep.", ["deep", "max"]),
+        stream: s.boolean("Emit report text as synthesis events upstream; results are retrieved through get_research_run."),
+        output_language: s.string("BCP 47 report language."),
+        weak_sources_enabled: s.boolean("Allow relevant social and community sources."),
+        domain_type: s.stringEnum("Source pool.", ["web", "news", "research_paper"]),
+        after_date: s.string("Include results on or after this date.", { format: "date" }),
+        before_date: s.string("Include results on or before this date.", { format: "date" }),
+        recency_minutes: s.integer("Freshness window; cannot combine with date filters.", {
+            minimum: 1,
+            maximum: 5256000,
+        }),
+        domain_filter: s.object("Domain preferences.", {
+            mode: s.stringEnum("Prioritize domains or restrict results exclusively to them.", ["include", "exclusive"]),
+            domains: s.array("Domains to prefer or require.", s.string("Domain."), { maxItems: 150 }),
+            block: s.array("Domains to exclude.", s.string("Domain."), { maxItems: 150 }),
+        }, { required: ["mode"] }),
+        prior_run_id: s.string("Completed report and evidence to reuse; mutually exclusive with session_id."),
+        session_id: s.string("Research session to continue; mutually exclusive with prior_run_id.", {
+            format: "uuid",
+        }),
+    }, { required: ["query"] }),
+    not: {
+        anyOf: [
+            { required: ["prior_run_id", "session_id"] },
+            { required: ["recency_minutes", "after_date"] },
+            { required: ["recency_minutes", "before_date"] },
+        ],
+    },
+};
+export const researchListInput = s.object("Research filters and cursor.", {
+    status: researchStatus,
+    query: s.string("Case-insensitive partial query filter.", { maxLength: 500 }),
+    created_after: s.string("Created after timestamp.", { format: "date-time" }),
+    created_before: s.string("Created before timestamp.", { format: "date-time" }),
+    sort_direction: s.stringEnum("Creation time sort order; defaults to desc.", ["asc", "desc"]),
+    cursor: s.string("Pagination cursor; replay with the same sort_direction."),
+    limit: s.integer("Maximum returned records.", { minimum: 1, maximum: 100 }),
+}, { required: [] });
+export const researchOutput = s.looseObject("Research status, reports and evidence.", {
+    research_run_id: researchId,
+    status: researchStatus,
+    query: s.string("Research question."),
+    quick_result: s.nullable(s.looseObject("Quick answer, citations and optional progress.")),
+    quick_result_summary: s.nullable(s.string("Quick answer summary.")),
+    deep_result: s.nullable(s.looseObject("Final report.", {
+        result: s.string("Report text."),
+        citations: s.array("Cited sources.", s.string("Source URL.")),
+        freshness_report: s.looseObject("Source freshness information."),
+        termination_reason: s.string("Reason research stopped; synthesis_failed indicates interim findings."),
+    })),
+    run_ids: s.array("Spawned agent run identifiers.", s.string("Agent run identifier.")),
+    created_at: s.nullable(s.string("Creation timestamp.")),
+    completed_at: s.nullable(s.string("Completion timestamp.")),
+    error: s.nullable(s.looseObject("Saved terminal outcome, not an HTTP request error.")),
+    research_plan: s.nullable(s.looseObject("Subquestions and planned searches.")),
+    evidence: s.nullable(s.array("Sources and supported claims.", s.looseObject("Evidence source."))),
+    iterations: s.nullable(s.integer("Completed research iterations.", { minimum: 0 })),
+});

package/src/providers/totp/runtime.js

@@ -1,5 +1,5 @@
 import { requiredString } from "../../core/cast.js";
-import { ProviderRequestError } from "../provider-runtime.js";
+import { ProviderRequestError, providerInputError } from "../provider-runtime.js";
 const base32Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 export const totpDigits = 6;
 export const totpPeriodSeconds = 30;
@@ -7,10 +7,9 @@ export const totpPeriodSeconds = 30;
  * Validate and normalize the three fields stored for a TOTP connection.
  */
 export function readTotpCredential(values) {
-    const createError = (message) => new ProviderRequestError(400, message);
-    const website = requiredString(values.website, "website", createError);
-    const username = requiredString(values.username, "username", createError);
-    const secret = requiredString(values.secret, "secret", createError);
+    const website = requiredString(values.website, "website", providerInputError);
+    const username = requiredString(values.username, "username", providerInputError);
+    const secret = requiredString(values.secret, "secret", providerInputError);
     const websiteUrl = parseWebsiteUrl(website);
     decodeBase32Secret(secret);
     return { website, username, secret, websiteUrl };

package/src/providers/trawlingweb/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { queryParams } from "../../core/request.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent, readProviderJsonBody, } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, readProviderJsonBody, providerInputError, } from "../provider-runtime.js";
 export const trawlingwebApiBaseUrl = "https://api.trawlingweb.com";
 export const trawlingwebActionHandlers = {
     search_news(input, context) {
@@ -106,6 +106,6 @@ function trawlingwebError(status, payload, phase) {
     if (status === 401 || status === 403)
         return new ProviderRequestError(phase === "validate" ? 400 : status, message);
     if (status === 400 || status === 404 || status === 422)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     return new ProviderRequestError(status >= 500 ? 502 : status, message);
 }

package/src/providers/trello/executors.js

@@ -1,3 +1,4 @@
+import { encodeRfc3986 } from "../../core/aws-sigv4.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { trelloActionHandlers, trelloApiBaseUrl, validateTrelloCredential } from "./runtime.js";
 const service = "trello";
@@ -23,9 +24,11 @@ export const proxy = async (input, context) => {
     try {
         const credential = await requireCustomCredential(context, service);
         const url = createProviderProxyUrl(trelloApiBaseUrl, input.endpoint, input.query);
-        url.searchParams.set("key", credential.values.apiKey);
-        url.searchParams.set("token", credential.values.apiToken);
+        url.searchParams.delete("key");
+        url.searchParams.delete("token");
         const headers = normalizeProviderProxyHeaders(input.headers);
+        // Trello attachment downloads require header authentication, unlike metadata reads.
+        headers.set("authorization", `OAuth oauth_consumer_key="${encodeRfc3986(credential.values.apiKey)}", oauth_token="${encodeRfc3986(credential.values.apiToken)}"`);
         headers.set("user-agent", providerUserAgent);
         const init = {
             method: input.method,

package/src/providers/trilium/runtime.js

@@ -420,13 +420,13 @@ function readErrorMessage(payload) {
 }
 function mapTriliumHttpError(status, message, phase) {
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && status === 401) {
         return new ProviderRequestError(401, message);
     }
     if (status === 400 || status === 403 || status === 404 || status === 409 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 429) {
         return new ProviderRequestError(429, message);

package/src/providers/triple_whale/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, objectArray, optionalBoolean, optionalNumber, optionalRecord, optionalString, } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 const tripleWhaleApiBaseUrl = "https://api.triplewhale.com/api/v2/";
 const tripleWhaleValidateApiKeyPath = "/users/api-keys/me";
 export const tripleWhaleActionHandlers = {
@@ -125,13 +125,13 @@ function createTripleWhaleError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && [400, 401, 403].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && [401, 403].includes(response.status)) {
         return new ProviderRequestError(401, message);
     }
     if (phase === "execute" && [400, 404, 422].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/truvera/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalRecord, optionalString, requiredRecord } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 const truveraTestnetApiBaseUrl = "https://api-testnet.truvera.io";
 const truveraProductionApiBaseUrl = "https://api.truvera.io";
 const truveraProfilePath = "/data/profile";
@@ -248,7 +248,7 @@ function createTruveraError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (response.status === 401 || response.status === 403)) {
         return new ProviderRequestError(401, message);

package/src/providers/tuskr/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, readProviderTextBody, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, readProviderTextBody, providerInputError, } from "../provider-runtime.js";
 export const tuskrApiBaseUrl = "https://api.tuskr.live/api";
 const maxResponseBytes = 10 * 1024 * 1024;
 export const tuskrActionHandlers = {
@@ -192,7 +192,7 @@ function createTuskrError(status, payload, phase) {
         optionalString(record?.errorMessage) ??
         `Tuskr request failed with status ${status}`;
     if ((status === 401 || status === 403) && phase === "validate") {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status >= 400 && status < 500)
         return new ProviderRequestError(status, message);

package/src/providers/typebot/runtime.js

@@ -1,6 +1,6 @@
 import { optionalBoolean, optionalInteger, optionalNumber, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
 import { queryParams } from "../../core/request.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent, readProviderJsonBody, } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, readProviderJsonBody, providerInputError, } from "../provider-runtime.js";
 export const typebotApiBaseUrl = "https://app.typebot.com/api";
 const validationPath = "/v1/workspaces";
 const get = (path, query) => (input, context) => requestTypebot(path(input), query?.(input), context, "execute");
@@ -80,6 +80,6 @@ function typebotError(response, payload, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : response.status, message);
     }
     if ([400, 404, 422].includes(response.status))
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     return new ProviderRequestError(response.status >= 500 ? 502 : response.status, message);
 }

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/typeform/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { fetchTypeformCurrentAccount, typeformActionHandlers, typeformApiBaseUrl, validateTypeformCredential, } from "./runtime.js";
+import { typeformResponse } from "./trigger-on-form-response.js";
 const service = "typeform";
 export const executors = defineBearerProviderExecutors(service, typeformActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return fetchTypeformCurrentAccount(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [typeformResponse];

package/src/providers/typeform/runtime.js

@@ -200,7 +200,7 @@ function mapTypeformError(input) {
     }
     if (input.phase === "validate") {
         if (input.status === 401 || input.status === 403) {
-            return new ProviderRequestError(400, message);
+            return providerInputError(message);
         }
         return new ProviderRequestError(input.status, message);
     }
@@ -208,7 +208,7 @@ function mapTypeformError(input) {
         return new ProviderRequestError(401, message);
     }
     if (input.status === 400 || (input.status === 404 && input.notFoundAsInvalidInput)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(input.status, message);
 }

package/src/providers/typeform/trigger-on-form-response.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const typeformResponse: IntegrationDefinition;

package/src/providers/typeform/trigger-on-form-response.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/typeform/trigger-on-form-response.definition.js

@@ -0,0 +1,40 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "typeform.on_form_response",
+    provider: "typeform",
+    name: "on_form_response",
+    displayName: "Completed Form Response",
+    description: "Receives complete Typeform submissions through an automatically managed signed webhook.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "formId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 128, title: "Form ID" },
+            nullable: false,
+        },
+    ],
+    outputs: [
+        {
+            handle: "response",
+            nullable: false,
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    eventId: s.string(),
+                    form_id: s.string(),
+                    token: s.string(),
+                    submitted_at: s.string(),
+                    answers: { type: "array", items: { type: "object" } },
+                    definition: { type: "object" },
+                },
+                required: ["eventId", "form_id", "token", "submitted_at", "answers"],
+            },
+        },
+    ],
+};

package/src/providers/typeform/trigger-on-form-response.js

@@ -0,0 +1,68 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-form-response.definition.js";
+export const typeformResponse = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        if (context.state == null)
+            throw new PermanentIntegrationError("Typeform subscription state is missing.");
+        const formId = context.config.formId;
+        if (typeof formId != "string" || !formId)
+            throw new PermanentIntegrationError("Choose a Typeform form.");
+        // A stable tag makes retries update the same webhook after a lost response.
+        const hash = await crypto.subtle.digest("SHA-256", bytes(context.endpointUrl));
+        const tag = `oomol-${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+        const endpoint = `/forms/${encodeURIComponent(formId)}/webhooks/${tag}`;
+        context.signal?.throwIfAborted();
+        const result = await context.connector.execute({
+            endpoint,
+            method: context.active ? "PUT" : "DELETE",
+            body: context.active
+                ? {
+                    url: context.endpointUrl,
+                    enabled: true,
+                    secret: context.callbackSecret,
+                    event_types: { form_response: true, form_response_partial: false },
+                }
+                : undefined,
+        }, context.signal);
+        context.signal?.throwIfAborted();
+        if (!(result.status >= 200 && result.status < 300) && !(!context.active && result.status == 404)) {
+            const message = `Typeform webhook operation failed (HTTP ${result.status}). Check form access and webhook permissions.`;
+            if (result.status >= 400 && result.status < 500 && result.status != 429)
+                throw new PermanentIntegrationError(message);
+            throw new TransientIntegrationError(message);
+        }
+        await context.state.saveSubscription(context.active ? { tag } : {}, new Date(context.now.getTime() + 24 * 60 * 60 * 1000));
+        return { outcome: "ready" };
+    },
+    async receive(context) {
+        const signature = context.header("typeform-signature");
+        if (!signature?.startsWith("sha256=") ||
+            !(await verifyBase64Hmac(context.callbackSecret, [context.rawBody], signature.slice(7))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || payload.event_type != "form_response")
+            return { outcome: "ignored", reason: "Only complete form responses are supported." };
+        const response = payload.form_response;
+        if (!isJsonObject(response) || response.form_id != context.config.formId)
+            return { outcome: "ignored", reason: "Typeform form does not match this subscription." };
+        if (typeof payload.event_id != "string" ||
+            !payload.event_id ||
+            typeof response.token != "string" ||
+            !response.token ||
+            typeof response.submitted_at != "string" ||
+            !response.submitted_at ||
+            !Array.isArray(response.answers) ||
+            response.answers.some((answer) => !isJsonObject(answer)) ||
+            ("definition" in response && !isJsonObject(response.definition)))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: response.token,
+            outputs: { response: { ...response, eventId: payload.event_id } },
+        };
+    },
+};

package/src/providers/uptimerobot/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, createProviderTimeout, defineApiKeyProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, normalizeProviderProxyQuery, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requiredResponseRecord, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, createProviderTimeout, defineApiKeyProviderExecutors, isAbortLikeError, normalizeProviderProxyHeaders, normalizeProviderProxyQuery, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireApiKeyCredential, requiredResponseRecord, toProviderProxyError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "uptimerobot";
 const uptimerobotApiBaseUrl = "https://api.uptimerobot.com/v2";
-const uptimerobotDefaultRequestTimeoutMs = 30_000;
 // Fixed-host proxy egress (uptimerobotApiBaseUrl); DNS-rebinding check is redundant here.
 const uptimerobotProxyFetch = createProviderFetch({ skipDnsValidation: true });
 export const uptimerobotActionHandlers = {
@@ -147,7 +146,7 @@ async function requestUptimerobotJson(input) {
     return body;
 }
 async function uptimerobotFetch(input) {
-    const timeout = createProviderTimeout(input.context.signal, uptimerobotDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.context.signal);
     const body = new URLSearchParams(input.body);
     body.set("api_key", input.context.apiKey);
     body.set("format", "json");
@@ -165,7 +164,7 @@ async function uptimerobotFetch(input) {
     }
     catch (error) {
         if (timeout.didTimeout() && isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `uptimerobot ${input.endpoint} request timed out after ${Math.ceil(uptimerobotDefaultRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `uptimerobot ${input.endpoint} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         throw new ProviderRequestError(isAbortLikeError(error) ? 504 : 502, error instanceof Error ? `uptimerobot request failed: ${error.message}` : "uptimerobot request failed");
     }

package/src/providers/v2ex/runtime.js

@@ -1,8 +1,7 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, requiredResponseRecord, providerInputError, providerResponseError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const v2exApiBaseUrl = "https://www.v2ex.com/api/v2";
 export const v2exLegacyApiBaseUrl = "https://www.v2ex.com/api";
-const v2exRequestTimeoutMs = 30_000;
 export const v2exActionHandlers = {
     async list_notifications(input, context) {
         const payload = await requestV2exJson({
@@ -186,7 +185,7 @@ async function requestV2exLegacyArray(input) {
     return payload;
 }
 async function requestV2exLegacyJson(input) {
-    const timeout = createProviderTimeout(input.signal, v2exRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     const url = new URL(`${v2exLegacyApiBaseUrl}${input.path}`);
     let response;
     let payload;
@@ -200,7 +199,7 @@ async function requestV2exLegacyJson(input) {
     }
     catch (error) {
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `V2EX legacy ${input.path} request timed out after ${Math.ceil(v2exRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `V2EX legacy ${input.path} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         if (error instanceof ProviderRequestError)
             throw error;
@@ -215,7 +214,7 @@ async function requestV2exLegacyJson(input) {
     return payload;
 }
 async function requestV2exJson(input) {
-    const timeout = createProviderTimeout(input.signal, v2exRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     const url = buildV2exUrl(input.path, input.query);
     let response;
     let payload;
@@ -230,7 +229,7 @@ async function requestV2exJson(input) {
     }
     catch (error) {
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `V2EX ${input.path} request timed out after ${Math.ceil(v2exRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `V2EX ${input.path} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         if (error instanceof ProviderRequestError)
             throw error;
@@ -339,7 +338,7 @@ function mapV2exError(status, message, phase, options) {
     if (status === 429)
         return new ProviderRequestError(429, resolvedMessage);
     if (phase === "validate" && (status === 401 || status === 403))
-        return new ProviderRequestError(400, resolvedMessage);
+        return providerInputError(resolvedMessage);
     if (authAware && phase === "execute" && status === 401)
         return new ProviderRequestError(401, resolvedMessage);
     if (phase === "execute" && status === 403)
@@ -349,6 +348,6 @@ function mapV2exError(status, message, phase, options) {
 function mapV2exSuccessError(message, phase) {
     const resolvedMessage = message || "V2EX request failed";
     if (phase === "validate")
-        return new ProviderRequestError(400, resolvedMessage);
-    return new ProviderRequestError(502, resolvedMessage);
+        return providerInputError(resolvedMessage);
+    return providerResponseError(resolvedMessage);
 }

package/src/providers/valyu/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, looseArray, optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const valyuApiBaseUrl = "https://api.valyu.ai";
 export const valyuActionHandlers = {
     async search(input, context) {
@@ -108,11 +108,11 @@ function createValyuError(response, payload, phase) {
     if (response.status === 429)
         return new ProviderRequestError(429, message);
     if (phase === "validate" && (response.status === 401 || response.status === 403))
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (phase === "execute" && response.status === 401)
         return new ProviderRequestError(401, message);
     if (response.status === 400 || response.status === 422)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     if (response.status === 402 || response.status === 403)
         return new ProviderRequestError(response.status, message);
     return new ProviderRequestError(response.status || 502, message);

package/src/providers/vapi/runtime.js

@@ -1,6 +1,6 @@
 import { base64Bytes, compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalRecord, } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { mapProviderActionSources, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { mapProviderActionSources, ProviderRequestError, providerUserAgent, providerInputError, } from "../provider-runtime.js";
 export const vapiApiBaseUrl = "https://api.vapi.ai";
 const vapiTimestampAliasMap = {
     created_at_ge: "createdAtGe",
@@ -330,7 +330,7 @@ async function resolveVapiUploadSource(input, context) {
     if (fileUrl) {
         const url = assertPublicHttpUrl(fileUrl, {
             fieldName: "file.url",
-            createError: (message) => new ProviderRequestError(400, message),
+            createError: providerInputError,
         });
         const response = await context.fetcher(url, { signal: context.signal });
         if (!response.ok) {
@@ -343,7 +343,7 @@ async function resolveVapiUploadSource(input, context) {
         };
     }
     try {
-        const bytes = base64Bytes(contentBase64, "file.contentBase64", (message) => new ProviderRequestError(400, message));
+        const bytes = base64Bytes(contentBase64, "file.contentBase64", providerInputError);
         return {
             bytes: bytes.buffer,
             fileName,
@@ -395,7 +395,7 @@ async function normalizeVapiError(response, mode) {
         return new ProviderRequestError(mode === "validate" ? 400 : 401, message);
     }
     if (response.status === 400 || response.status === 404 || response.status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (response.status === 429) {
         return new ProviderRequestError(429, message);

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

@@ -0,0 +1,13 @@
+import type { ActionDefinition } from "../../core/types.ts";
+interface VaquillOperation {
+    name: string;
+    method: string;
+    path: string;
+    query: string[];
+    pathKeys: string[];
+    action: ActionDefinition;
+}
+declare const vaquillOperations: readonly VaquillOperation[];
+export declare const vaquillActions: ActionDefinition[];
+export declare const vaquillOperationByName: Map<string, (typeof vaquillOperations)[number]>;
+export {};