@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/kommo/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, nullableInteger, nullableString, optionalBoolean, optionalInteger, optionalRecord, optionalString, } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, requiredResponseRecord, runProviderRequest, providerInputError, } from "../provider-runtime.js";
 const kommoCredentialHelpUrl = "https://developers.kommo.com/docs/long-lived-token";
 const kommoPrivateIntegrationHelpUrl = "https://developers.kommo.com/docs/private-integration";
 const kommoHostSuffix = ".kommo.com";
@@ -277,7 +277,7 @@ function createKommoError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (status === 401 || status === 403)) {
         return new ProviderRequestError(status, message);

package/src/providers/kontent_ai/executors.js

@@ -1,8 +1,7 @@
 import { optionalBoolean, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, } from "../provider-runtime.js";
+import { createProviderTimeout, defineProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, requireApiKeyCredential, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "kontent_ai";
 const kontentAiApiBaseUrl = "https://manage.kontent.ai/v2";
-const kontentAiDefaultRequestTimeoutMs = 30_000;
 export const kontentAiActionHandlers = {
     list_content_items(input, context) {
         return listKontentAiContentItems(input, context);
@@ -189,7 +188,7 @@ async function getKontentAiLanguage(input, context) {
     };
 }
 async function requestKontentAiJson(input) {
-    const timeout = createProviderTimeout(input.signal, kontentAiDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(input.signal);
     let response;
     let payload;
     try {
@@ -214,7 +213,7 @@ async function requestKontentAiJson(input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Kontent.ai ${input.path} request timed out after ${Math.ceil(kontentAiDefaultRequestTimeoutMs / 1000)} seconds`);
+            throw new ProviderRequestError(504, `Kontent.ai ${input.path} request timed out after ${Math.ceil(defaultProviderRequestTimeoutMs / 1000)} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error
             ? `Kontent.ai ${input.path} request failed: ${error.message}`

package/src/providers/l2s/executors.js

@@ -1,9 +1,8 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerInputError, providerUserAgent, ProviderRequestError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "l2s";
 const l2sApiBaseUrl = "https://api.l2s.is";
 const l2sValidationPath = "/user/setting";
-const l2sDefaultRequestTimeoutMs = 30_000;
 export const l2sActionHandlers = {
     shorten_url(input, context) {
         return l2sRequest(context, {
@@ -74,7 +73,7 @@ async function validateL2sCredential(context) {
     };
 }
 async function l2sRequest(context, input) {
-    const timeout = createProviderTimeout(context.signal, l2sDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(new URL(input.path, l2sApiBaseUrl), {
             method: input.method,
@@ -98,7 +97,7 @@ async function l2sRequest(context, input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `L2S ${input.path} request timed out after ${Math.max(1, Math.ceil(l2sDefaultRequestTimeoutMs / 1000))} seconds`);
+            throw new ProviderRequestError(504, `L2S ${input.path} request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `L2S request failed: ${error.message}` : "L2S request failed");
     }

package/src/providers/latchshot/executors.js

@@ -147,7 +147,7 @@ async function createLatchshotError(response, phase) {
     const text = await readProviderTextBody(response, "Latchshot error response", latchshotJsonMaxBytes);
     const message = extractLatchshotErrorMessage(text) ?? `Latchshot request failed with HTTP ${response.status}.`;
     if (phase === "validate" && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if ([400, 401, 403, 413, 429].includes(response.status)) {
         return new ProviderRequestError(response.status, message);
@@ -240,7 +240,7 @@ function requireObject(value, message) {
     if (record) {
         return record;
     }
-    throw new ProviderRequestError(502, message);
+    throw providerResponseError(message);
 }
 function requireNonNegativeInteger(value, fieldName, positive = false) {
     const resolved = optionalInteger(value);

package/src/providers/leadboxer/runtime.js

@@ -1,7 +1,7 @@
 import { isIP } from "node:net";
 import { domainToASCII } from "node:url";
 import { optionalRecord, requiredString } from "../../core/cast.js";
-import { createProviderTimeout, getProviderActionHandler, ProviderRequestError, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
+import { createProviderTimeout, getProviderActionHandler, ProviderRequestError, providerUserAgent, requiredResponseRecord, providerInputError, } from "../provider-runtime.js";
 export const leadboxerApiBaseUrl = "https://api.leadboxer.com";
 const leadboxerValidationEndpoint = "/v1/management/credits";
 const leadboxerActionHandlers = {
@@ -14,7 +14,7 @@ const leadboxerActionHandlers = {
 };
 export async function validateLeadboxerCredential(input, fetcher) {
     const payload = await requestLeadboxerJson({
-        apiKey: requiredString(input.apiKey, "apiKey", (message) => new ProviderRequestError(400, message)),
+        apiKey: requiredString(input.apiKey, "apiKey", providerInputError),
         path: leadboxerValidationEndpoint,
         fetcher,
         phase: "validate",
@@ -153,7 +153,7 @@ function createLeadboxerError(response, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && response.status >= 400 && response.status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && response.status === 401) {
         return new ProviderRequestError(401, message);
@@ -162,7 +162,7 @@ function createLeadboxerError(response, payload, phase) {
         return new ProviderRequestError(403, message);
     }
     if (phase === "execute" && (response.status === 400 || response.status === 404 || response.status === 409)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 500, message);
 }

package/src/providers/leadiq/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString, requiredRecord } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const leadiqApiBaseUrl = "https://api.leadiq.com";
 export const leadiqGraphqlPath = "/graphql";
 const accountQuery = `
@@ -108,7 +108,7 @@ function requireAdvancedSearchFilter(input) {
 }
 function requireAnyStringField(input, fields, message) {
     if (!fields.some((field) => typeof input[field] === "string" && input[field].trim().length > 0)) {
-        throw new ProviderRequestError(400, message);
+        throw providerInputError(message);
     }
 }
 export async function validateLeadiqCredential(input, fetcher) {
@@ -197,9 +197,9 @@ function mapLeadiqError(status, message, phase) {
         return new ProviderRequestError(429, message);
     }
     if (status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function requireGraphqlObject(data, field) {
     const value = optionalRecord(data[field]);

package/src/providers/linguapop/runtime.js

@@ -153,7 +153,7 @@ function mapLinguapopError(status, message, phase) {
         return new ProviderRequestError(401, message);
     }
     if (status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status || 502, message);
 }

package/src/providers/lingvanex_translation_api/runtime.js

@@ -1,8 +1,7 @@
 import { optionalRawString, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, providerUserAgent, ProviderRequestError, requiredResponseRecord, } from "../provider-runtime.js";
+import { createProviderTimeout, providerUserAgent, ProviderRequestError, requiredResponseRecord, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const lingvanexTranslationApiBaseUrl = "https://api-gl.lingvanex.com";
 const translationPath = "/language/translate/v2";
-const requestTimeoutMs = 30_000;
 export const lingvanexTranslationApiActionHandlers = {
     translate_text(input, context) {
         return translateText(input, context);
@@ -122,7 +121,7 @@ async function requestLingvanexJson(input, context, phase) {
         }
     }
     url.searchParams.set("key", context.apiKey);
-    const timeout = createProviderTimeout(context.signal, requestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     let response;
     let payload;
     try {
@@ -138,7 +137,7 @@ async function requestLingvanexJson(input, context, phase) {
     }
     catch (error) {
         if (timeout.didTimeout()) {
-            throw new ProviderRequestError(504, `Lingvanex request timed out after ${requestTimeoutMs / 1000} seconds`);
+            throw new ProviderRequestError(504, `Lingvanex request timed out after ${defaultProviderRequestTimeoutMs / 1000} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Lingvanex request failed: ${error.message}` : "Lingvanex request failed");
     }
@@ -168,13 +167,13 @@ function createLingvanexError(status, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     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);
     }
     if (status === 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status >= 500 ? 502 : status, message);
 }

package/src/providers/lingxing_mcp/runtime.js

@@ -5,9 +5,8 @@ import { createHash } from "node:crypto";
 import { optionalNumber, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
 import { withMcpClient } from "../mcp-client.js";
-import { providerUserAgent, ProviderRequestError, toProviderExecutionError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, toProviderExecutionError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const lingxingMcpHost = "openmcp.lingxing.com";
-const lingxingRequestTimeoutMs = 30_000;
 const lingxingToolIntervalMs = 1_000;
 const maximumTrackedRateLimitKeys = 1_024;
 class InMemoryLingxingMcpRateLimiter {
@@ -137,7 +136,7 @@ export async function callLingxingTool(context, input) {
             name: toolName,
             arguments: argumentsValue,
         }, {
-            timeout: lingxingRequestTimeoutMs,
+            timeout: defaultProviderRequestTimeoutMs,
             signal: context.signal,
         });
         return normalizeLingxingMcpToolResult(toolName, toolResult);
@@ -147,7 +146,7 @@ export async function callLingxingTool(context, input) {
 async function discoverLingxingTools(context) {
     return withLingxingMcpClient(context, async (client) => {
         const result = await client.listTools({}, {
-            timeout: lingxingRequestTimeoutMs,
+            timeout: defaultProviderRequestTimeoutMs,
             signal: context.signal,
         });
         return result.tools.map((tool) => {

package/src/providers/linkup/runtime.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 export const linkupApiBaseUrl = "https://api.linkup.so";
 const linkupValidationPath = "/v1/credits/balance";
-const linkupDefaultRequestTimeoutMs = 30_000;
 export const linkupActionHandlers = {
     get_credits_balance(_input, context) {
         return linkupRequest(context, {
@@ -98,7 +97,7 @@ export async function validateLinkupCredential(apiKey, fetcher, signal) {
     };
 }
 async function linkupRequest(context, input) {
-    const timeout = createProviderTimeout(context.signal, linkupDefaultRequestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(new URL(input.path, linkupApiBaseUrl), {
             method: input.method,
@@ -122,7 +121,7 @@ async function linkupRequest(context, input) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Linkup ${input.path} request timed out after ${Math.max(1, Math.ceil(linkupDefaultRequestTimeoutMs / 1000))} seconds`);
+            throw new ProviderRequestError(504, `Linkup ${input.path} request timed out after ${Math.max(1, Math.ceil(defaultProviderRequestTimeoutMs / 1000))} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Linkup request failed: ${error.message}` : "Linkup request failed");
     }
@@ -151,13 +150,13 @@ function buildLinkupError(response, payload, mode) {
         return new ProviderRequestError(429, message);
     }
     if (mode === "validate" && [400, 401, 403].includes(response.status)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (mode === "execute" && [401, 403].includes(response.status)) {
         return new ProviderRequestError(401, message);
     }
     if (mode === "execute" && response.status === 400) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(response.status || 502, message);
 }

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

@@ -0,0 +1,12 @@
+import type { ActionDefinition } from "../../core/types.ts";
+import { dataTools } from "./tools.ts";
+interface LitescrapeEndpoint {
+    path: string;
+    method: "GET" | "POST" | "PATCH";
+    action: ActionDefinition;
+}
+declare const litescrapeEndpoints: LitescrapeEndpoint[];
+export declare const litescrapeActions: ActionDefinition[];
+export declare const litescrapeEndpointByName: Map<string, (typeof litescrapeEndpoints)[number]>;
+export declare const litescrapeToolByName: Map<string, (typeof dataTools)[number]>;
+export {};

package/src/providers/litescrape/actions.js

@@ -0,0 +1,124 @@
+import { readSchemaProperties } from "../../core/json-schema.js";
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { dataTools } from "./tools.js";
+const empty = s.requiredObject("No parameters.", {});
+const accountOutput = s.looseObject("Account response with upstream fields preserved.", {});
+const jobOutput = s.looseObject("Asynchronous job state and retained result.", {
+    job_id: s.string("Job ID used to poll for the result."),
+    state: s.stringEnum("Job state; queued includes retry backoff.", [
+        "queued",
+        "running",
+        "succeeded",
+        "failed",
+        "expired",
+    ]),
+    status_code: s.nullableInteger("Final scraper HTTP status, or null before completion."),
+    response: s.nullable(s.looseObject("Retained scraper result or error; screenshots use a file URL.", {})),
+    created_at: s.string("Submission time."),
+    completed_at: s.nullableString("Completion time, or null before completion."),
+    expires_at: s.nullableString("Expiry time, 24 hours after completion."),
+});
+const timeout = s.number("Upstream execution budget in seconds, excluding queue time.", {
+    exclusiveMinimum: 0,
+    maximum: 90,
+});
+function endpoint(name, description, path, method, input, output, operationType = "read") {
+    return {
+        path,
+        method,
+        action: defineProviderAction("litescrape", {
+            name,
+            description,
+            operationType,
+            requiredScopes: [],
+            inputSchema: input,
+            outputSchema: output,
+            asyncLifecycle: name.startsWith("submit_")
+                ? { startActionId: `litescrape.${name}`, statusActionId: "litescrape.get_job" }
+                : undefined,
+        }),
+    };
+}
+const screenshot = dataTools.find((tool) => tool.name === "web_screenshot");
+screenshot.output = s.looseObject("Screenshot metadata and hosted PNG file.", {
+    url: s.string("Captured page URL."),
+    title: s.nullableString("Page title."),
+    description: s.nullableString("Page description."),
+    full_page: s.boolean("Whether the full page was captured."),
+    screenshot: s.requiredObject("Hosted screenshot file.", {
+        url: s.string("Download URL."),
+        mimeType: s.literal("image/png", {
+            description: "File media type.",
+        }),
+    }),
+});
+const litescrapeEndpoints = [
+    ...dataTools.map((tool) => endpoint(tool.name, tool.description, tool.path, "POST", s.object(String(tool.input.description), { ...readSchemaProperties(tool.input), timeout }, { required: tool.input.required ?? [] }), tool.output, tool.name === "web_fetch" || tool.name === "web_screenshot" ? "destructive" : "read")),
+    ...dataTools.map((tool) => endpoint(`submit_${tool.name}`, `Submit asynchronously: ${tool.description} Reuse idempotencyKey for retries. Results expire after 24 hours; zero data retention accounts cannot submit or poll retained jobs.`, `${tool.path}/async`, "POST", s.object(`${tool.name} asynchronous submission.`, {
+        body: tool.asyncInput,
+        idempotencyKey: s.string("Optional retry identity; generated when omitted.", {
+            minLength: 16,
+            maxLength: 128,
+        }),
+        batchId: s.string("Optional compatibility batch ID; does not change billing.", {
+            minLength: 16,
+            maxLength: 128,
+        }),
+        batchSize: s.integer("Optional compatibility batch size; does not change billing.", {
+            minimum: 0,
+            maximum: 1000000000,
+        }),
+    }, { optional: ["idempotencyKey", "batchId", "batchSize"] }), jobOutput, tool.name === "web_fetch" || tool.name === "web_screenshot" ? "destructive" : "write")),
+    endpoint("get_job", "Read asynchronous job state and its retained response. Failed jobs return their original status_code and error response.", "/api/batch/jobs/{job_id}", "GET", s.requiredObject("Job lookup.", { job_id: s.string("Job ID.", { pattern: "^[0-9a-f]{32}$" }) }), jobOutput, "read"),
+    endpoint("get_key_status", "Read key status, balance, concurrency and retention settings without a paid search.", "/api/keys/status", "GET", empty, accountOutput),
+    endpoint("set_zero_data_retention", "Enable or disable zero data retention. Enabling it deletes completed batch results and disables new asynchronous jobs and screenshots. Active batch jobs must finish first.", "/api/keys/zdr", "PATCH", s.requiredObject("Retention settings.", {
+        zdr_enabled: s.boolean("Whether zero data retention is enabled."),
+    }), accountOutput, "destructive"),
+    endpoint("rotate_key", "Replace the API key and immediately invalidate the current key. Save the returned key and reconnect before making another request.", "/api/keys/rotate", "POST", empty, accountOutput, "destructive"),
+    endpoint("get_usage", "Read account usage for a time range and timezone.", "/api/usage", "GET", s.object("Usage filters.", {
+        range: s.stringEnum("Reporting window.", ["24h", "7d", "30d", "90d"]),
+        tz: s.string("IANA timezone; defaults to UTC upstream."),
+    }, { optional: ["range", "tz"] }), accountOutput),
+    endpoint("create_checkout", "Create a credit-purchase checkout URL. Payment completes only after opening and completing checkout.", "/api/billing/checkout", "POST", s.object("Checkout options.", { return_path: s.stringEnum("Website return path.", ["/", "/try/google-search"]) }, { optional: ["return_path"] }), accountOutput, "write"),
+    endpoint("get_auto_top_up", "Read automatic top-up settings.", "/api/billing/auto-top-up", "GET", empty, accountOutput),
+    endpoint("disable_auto_top_up", "Disable automatic credit charges.", "/api/billing/auto-top-up", "PATCH", empty, accountOutput, "destructive"),
+    endpoint("setup_auto_top_up", "Create a checkout URL to authorize automatic top-ups. Complete card authorization at the returned URL.", "/api/billing/auto-top-up/setup", "POST", s.requiredObject("Automatic top-up authorization.", {
+        threshold_units: s.integer("Remaining calls threshold; must be below calls purchased by one top-up.", {
+            minimum: 1,
+        }),
+        top_up_cents: s.integer("Top-up amount in US cents.", { minimum: 1000, maximum: 100000 }),
+        monthly_limit_cents: s.integer("UTC calendar-month limit in US cents; must cover one top-up.", {
+            maximum: 1000000,
+        }),
+        consent: s.literal(true, {
+            description: "Explicit consent to configure automatic top-ups.",
+        }),
+    }), accountOutput, "write"),
+    endpoint("get_email_bonus", "Read email bonus eligibility and claim status; this does not claim the bonus.", "/api/keys/email-bonus", "GET", empty, accountOutput),
+    endpoint("find_tools", "Find relevant data tools or retrieve their input schemas by name.", "/api/tools", "POST", s.object("Tool discovery query.", {
+        q: s.string("Use case; required unless names is supplied.", {
+            minLength: 3,
+            maxLength: 500,
+        }),
+        limit: s.integer("Maximum number of tools.", { minimum: 1, maximum: 25 }),
+        names: s.array("Tool names to retrieve without ranking.", s.string("Tool name."), {
+            minItems: 1,
+            maxItems: 25,
+        }),
+    }, { optional: ["q", "limit", "names"], anyOf: [{ required: ["q"] }, { required: ["names"] }] }), s.looseObject("Matching tools.", {
+        tools: s.array("Tools ordered by relevance or requested name.", s.looseObject("Tool metadata and input schema.", {})),
+    })),
+    endpoint("submit_feedback", "Submit an explicitly requested rating about a previous result. Each feedback token expires after seven days and accepts one rating.", "/api/feedback/{token}", "POST", s.object("Result feedback.", {
+        token: s.string("Token from the feedback URL.", { minLength: 1, maxLength: 2048 }),
+        rating: s.integer("Result rating from 1 to 5.", { minimum: 1, maximum: 5 }),
+        comment: s.string("Evaluation without secrets or personal data.", {
+            minLength: 1,
+            maxLength: 4000,
+        }),
+        agent: s.nullableString("Optional agent or model name.", { minLength: 1, maxLength: 120 }),
+    }, { optional: ["agent"] }), accountOutput, "write"),
+];
+export const litescrapeActions = litescrapeEndpoints.map((endpoint) => endpoint.action);
+export const litescrapeEndpointByName = new Map(litescrapeEndpoints.map((endpoint) => [endpoint.action.name, endpoint]));
+export const litescrapeToolByName = new Map(dataTools.map((tool) => [tool.name, tool]));

package/src/providers/litescrape/airbnb-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { DataTool } from "./shared.ts";
+export declare const airbnbTools: DataTool[];

package/src/providers/litescrape/airbnb-schemas.js

@@ -0,0 +1,72 @@
+import { s } from "../../core/json-schema.js";
+export const airbnbTools = [
+    {
+        name: "airbnb_search",
+        path: "/api/airbnb/search",
+        description: "Search Airbnb stays by destination and dates.",
+        input: s.object("Airbnb Search parameters.", {
+            q: s.nullable(s.string("Destination, address, or landmark.", { maxLength: 500 })),
+            map_bounds: s.nullable(s.string("North,east,south,west map coordinates.")),
+            airbnb_domain: s.string("Airbnb localization domain."),
+            currency: s.nullable(s.string("Currency code for returned prices.")),
+            check_in_date: s.nullable(s.string("Check-in date in YYYY-MM-DD format.", { format: "date" })),
+            check_out_date: s.nullable(s.string("Check-out date, later than check-in.", { format: "date" })),
+            adults: s.nullable(s.integer("Number of guests aged 13 or above.", { minimum: 0 })),
+            children: s.nullable(s.integer("Number of guests aged 2 to 12.", { minimum: 0 })),
+            infants: s.nullable(s.integer("Number of guests under 2.", { minimum: 0 })),
+            pets: s.nullable(s.integer("Number of pets.", { minimum: 0 })),
+            room_type: s.nullable(s.withEnum(s.unknown("Type of place."), ["entire_home", "private_room"])),
+            min_price: s.nullable(s.number("Minimum total trip price including fees.", { minimum: 0 })),
+            max_price: s.nullable(s.number("Maximum total trip price including fees.", { minimum: 0 })),
+            bedrooms: s.nullable(s.integer("Minimum bedrooms.", { minimum: 0 })),
+            beds: s.nullable(s.integer("Minimum beds.", { minimum: 0 })),
+            bathrooms: s.nullable(s.number("Minimum bathrooms.", { minimum: 0 })),
+            property_types: s.nullable(s.string("Comma-separated property types.")),
+            amenities: s.nullable(s.string("Comma-separated required amenities.")),
+            accessibility_features: s.nullable(s.string("Comma-separated accessibility features.")),
+            host_languages: s.nullable(s.string("Comma-separated host language codes.")),
+            instant_book: s.boolean("Require instant booking."),
+            self_check_in: s.boolean("Require self check-in."),
+            guest_favorite: s.boolean("Only Guest favorites."),
+            luxe: s.boolean("Only Airbnb Luxe places."),
+            page: s.integer("Results page, from 1 to 15.", { minimum: 1, maximum: 15 }),
+        }, { required: [] }),
+        asyncInput: s.object("Airbnb Search asynchronous parameters.", {
+            q: s.string("Destination, address, or landmark.", { maxLength: 500 }),
+            map_bounds: s.string("North,east,south,west map coordinates."),
+            airbnb_domain: s.string("Airbnb localization domain."),
+            currency: s.string("Currency code for returned prices."),
+            check_in_date: s.string("Check-in date in YYYY-MM-DD format.", { format: "date" }),
+            check_out_date: s.string("Check-out date, later than check-in.", { format: "date" }),
+            adults: s.integer("Number of guests aged 13 or above.", { minimum: 0 }),
+            children: s.integer("Number of guests aged 2 to 12.", { minimum: 0 }),
+            infants: s.integer("Number of guests under 2.", { minimum: 0 }),
+            pets: s.integer("Number of pets.", { minimum: 0 }),
+            room_type: s.withEnum(s.unknown("Type of place."), ["entire_home", "private_room"]),
+            min_price: s.number("Minimum total trip price including fees.", { minimum: 0 }),
+            max_price: s.number("Maximum total trip price including fees.", { minimum: 0 }),
+            bedrooms: s.integer("Minimum bedrooms.", { minimum: 0 }),
+            beds: s.integer("Minimum beds.", { minimum: 0 }),
+            bathrooms: s.number("Minimum bathrooms.", { minimum: 0 }),
+            property_types: s.string("Comma-separated property types."),
+            amenities: s.string("Comma-separated required amenities."),
+            accessibility_features: s.string("Comma-separated accessibility features."),
+            host_languages: s.string("Comma-separated host language codes."),
+            instant_book: s.boolean("Require instant booking."),
+            self_check_in: s.boolean("Require self check-in."),
+            guest_favorite: s.boolean("Only Guest favorites."),
+            luxe: s.boolean("Only Airbnb Luxe places."),
+            page: s.integer("Results page, from 1 to 15.", { minimum: 1, maximum: 15 }),
+            timeout: s.number("Execution budget in seconds for each attempt. Queue and retry backoff time do not consume it. Supply once, in the JSON body or query string.", { maximum: 90, exclusiveMinimum: 0 }),
+        }, { required: [] }),
+        output: s.looseObject("Airbnb Search response.", {
+            search_metadata: s.looseObject("search metadata value.", {}),
+            search_parameters: s.looseObject("search parameters value.", {}),
+            organic_results: s.array("organic results value.", s.looseObject("organic results value. item.", {})),
+            pagination: s.nullable(s.looseObject("pagination value.", {})),
+            submit_feedback_for_this_response_here: s.string("Optional URL for submitting feedback about this result.", {
+                format: "uri",
+            }),
+        }),
+    },
+];

package/src/providers/litescrape/aliexpress-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { DataTool } from "./shared.ts";
+export declare const aliexpressTools: DataTool[];

package/src/providers/litescrape/aliexpress-schemas.js

@@ -0,0 +1,52 @@
+import { s } from "../../core/json-schema.js";
+export const aliexpressTools = [
+    {
+        name: "aliexpress_product",
+        path: "/api/aliexpress/product",
+        description: "Get an AliExpress product's details and price. This upstream API is Alpha.",
+        input: s.object("AliExpress Product parameters.", {
+            url: s.string("Public HTTPS product URL on this retailer's site.", {
+                minLength: 1,
+                maxLength: 4096,
+            }),
+        }, { required: ["url"] }),
+        asyncInput: s.object("AliExpress Product asynchronous parameters.", {
+            url: s.string("Public HTTPS product URL on this retailer's site.", {
+                minLength: 1,
+                maxLength: 4096,
+            }),
+            timeout: s.number("Execution budget in seconds for each attempt. Queue and retry backoff time do not consume it. Supply once, in the JSON body or query string.", { maximum: 90, exclusiveMinimum: 0 }),
+        }, { required: ["url"] }),
+        output: s.looseObject("AliExpress Product response.", {
+            search_metadata: s.looseObject("search metadata value.", {}),
+            search_parameters: s.looseObject("search parameters value.", {}),
+            product: s.looseObject("product value.", {}),
+            submit_feedback_for_this_response_here: s.string("Optional URL for submitting feedback about this result.", {
+                format: "uri",
+            }),
+        }),
+    },
+    {
+        name: "aliexpress_search",
+        path: "/api/aliexpress/search",
+        description: "Search AliExpress products with prices. This upstream API is Alpha.",
+        input: s.object("AliExpress Search parameters.", {
+            query: s.string("Product keywords to search for.", { minLength: 1, maxLength: 500 }),
+            page: s.integer("One-based result page.", { minimum: 1, maximum: 100 }),
+        }, { required: ["query"] }),
+        asyncInput: s.object("AliExpress Search asynchronous parameters.", {
+            query: s.string("Product keywords to search for.", { minLength: 1, maxLength: 500 }),
+            page: s.integer("One-based result page.", { minimum: 1, maximum: 100 }),
+            timeout: s.number("Execution budget in seconds for each attempt. Queue and retry backoff time do not consume it. Supply once, in the JSON body or query string.", { maximum: 90, exclusiveMinimum: 0 }),
+        }, { required: ["query"] }),
+        output: s.looseObject("AliExpress Search response.", {
+            search_metadata: s.looseObject("search metadata value.", {}),
+            search_parameters: s.looseObject("search parameters value.", {}),
+            products: s.array("products value.", s.looseObject("products value. item.", {})),
+            pagination: s.looseObject("pagination value.", {}),
+            submit_feedback_for_this_response_here: s.string("Optional URL for submitting feedback about this result.", {
+                format: "uri",
+            }),
+        }),
+    },
+];

package/src/providers/litescrape/amazon-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { DataTool } from "./shared.ts";
+export declare const amazonTools: DataTool[];