@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/kolsprite_mcp/executors.js

@@ -0,0 +1,89 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { callMcpTool, listMcpTools } from "../mcp-tools.js";
+import { requiredResponseRecord, requiredInputString, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { kolspriteMcpActions } from "./actions.js";
+const origin = "https://mcp.kolsprite.com";
+const endpoint = `${origin}/mcp`;
+function connectionInput(key, fetcher, signal) {
+    return {
+        endpoint,
+        signal,
+        service: "KOLSprite",
+        headers: { "secret-key": key },
+        fetcher,
+        redirect: "manual",
+        maxResponseBytes: 16 * 1024 * 1024,
+    };
+}
+function parseResponse(result) {
+    let body = requiredResponseRecord(result, "KOLSprite MCP");
+    if (Array.isArray(body.content)) {
+        const content = body.content;
+        const block = content.length === 1 ? optionalRecord(content[0]) : undefined;
+        const text = block?.type === "text" ? optionalString(block.text) : undefined;
+        if (text === undefined) {
+            throw providerResponseError("KOLSprite MCP returned an unsupported content response");
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(text);
+        }
+        catch {
+            throw providerResponseError("KOLSprite MCP returned invalid JSON");
+        }
+        body = requiredResponseRecord(decoded, "KOLSprite MCP");
+    }
+    const code = optionalString(body.code);
+    if (body.success === false || (code !== undefined && code !== "OK")) {
+        const message = optionalString(body.message) ?? "Tool request failed";
+        throw providerResponseError(`KOLSprite ${code ?? "error"}: ${message}`);
+    }
+    if (!("data" in body)) {
+        throw providerResponseError("KOLSprite MCP response is missing data");
+    }
+    return body;
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const args = values;
+    if (typeof args.page_num === "number" &&
+        typeof args.page_size === "number" &&
+        args.page_num * args.page_size > 1000) {
+        throw providerInputError("page_num multiplied by page_size must not exceed 1000");
+    }
+    const key = requiredInputString(apiKey, "MCP Key");
+    const result = await callMcpTool({
+        ...connectionInput(key, fetcher, context.signal),
+        toolName: actionName,
+        arguments: args,
+    });
+    return parseResponse(result);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const key = requiredInputString(input.apiKey, "MCP Key");
+        const tools = await listMcpTools(connectionInput(key, fetcher, signal));
+        const hash = sha256Hex(key);
+        return {
+            profile: { accountId: `kolsprite-mcp:${hash}`, displayName: `KOLSprite MCP · ${hash.slice(-6)}` },
+            grantedScopes: [],
+            metadata: { mcpEndpoint: endpoint, discoveredToolCount: tools.length },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("kolsprite_mcp", Object.fromEntries(kolspriteMcpActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "kolsprite_mcp",
+    baseUrl: origin,
+    auth: { type: "api_key_header", name: "secret-key" },
+    redirect: "manual",
+    allowedEndpoint(value) {
+        return new URL(value, origin).href === endpoint;
+    },
+    customizeRequest({ url, headers }) {
+        if (url.href !== endpoint)
+            throw providerInputError("KOLSprite MCP proxy only supports /mcp without a query string");
+        headers.set("accept", "application/json, text/event-stream");
+    },
+});

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[];